refactor(lang): rename the fn keyword to function

Expand the function-declaration keyword to the full word across the whole
language and toolchain:
  fn name(...) -> T { ... }   ->   function name(...) -> T { ... }

Done as a self-hosting migration: teach the parser both spellings, reseed,
rewrite every .ludic definition to `function`, then drop `fn`. The compiler
now rejects `fn`. Touches the parser, all selfhost/tools/runtime/example/test
sources, the grammars (TextMate shared+vscode, ludic_syntax.h, JetBrains
LudicTokens.kt), the LSP and formatter, the Python doc/vocab tools
(check-impl, check-docs, validate, palette, test-lsp), and the docs
(fences, prose, kw-fn -> kw-function).

Reseeded; C-free bootstrap fixpoint holds. All suites green (45 regression,
24 self-host, 29 tool); the docs site generates and check.py passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

examples/chronorift/rules.ludic

@@ -1,6 +1,6 @@
 # rules.ludic — pure game rules & map data (functions only, no systems).
 
-fn tile_sprite(c: int) -> int {
+function tile_sprite(c: int) -> int {
   match c {
     'T', '#' => return SPR_TREE
     'H' => return SPR_HOUSE
@@ -11,18 +11,18 @@ fn tile_sprite(c: int) -> int {
   }
   return SPR_GRASS
 }
-fn walkable(x: int, y: int) -> bool {
+function walkable(x: int, y: int) -> bool {
   let c = Map.tile(x, y)
   return c == '.' or c == 'D' or c == 'r' or c == ',' or c == 'S' or c == 'B' or c == 'h'
 }
-fn is_confirm(k: int) -> bool { return k == 32 or k == 10 or k == 13 }
-fn enemy_name(et: int) -> str {
+function is_confirm(k: int) -> bool { return k == 32 or k == 10 or k == 13 }
+function enemy_name(et: int) -> str {
   if et == 0 { return "SLIME" }
   if et == 1 { return "SKELETON" }
   return "RIFT WARDEN"
 }
 
-fn build_field(x: int) -> int {
+function build_field(x: int) -> int {
   Map.size(40, 18)
   Map.row(0,  "########################################")
   Map.row(1,  "#......................................#")
@@ -44,7 +44,7 @@ fn build_field(x: int) -> int {
   Map.row(17, "########################################")
   return 0
 }
-fn build_dungeon(x: int) -> int {
+function build_dungeon(x: int) -> int {
   Map.size(40, 18)
   Map.row(0,  "========================================")
   Map.row(1,  "=,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,=")
@@ -67,7 +67,7 @@ fn build_dungeon(x: int) -> int {
   return 0
 }
 
-fn grant_xp(amount: int) -> int {
+function grant_xp(amount: int) -> int {
   for (t) in query [Stats, {Party}] {
     if t.hp > 0 {
       t.xp = t.xp + amount

examples/lib/arena.ludic

@@ -11,9 +11,9 @@
 # ============================================================================
 program Arena {
 
-  extern fn damage(attack: int, armour: int, roll: int) -> int = "damage"
-  extern fn hits_to_kill(hp: int, attack: int, armour: int) -> int = "hits_to_kill"
-  extern fn xp_for(level: int, kills: int) -> int = "xp_for"
+  extern function damage(attack: int, armour: int, roll: int) -> int = "damage"
+  extern function hits_to_kill(hp: int, attack: int, armour: int) -> int = "hits_to_kill"
+  extern function xp_for(level: int, kills: int) -> int = "xp_for"
 
   property Fighter { hp: int = 30, attack: int = 9, armour: int = 2 }
 

examples/lib/combat.ludic

@@ -16,7 +16,7 @@ program Combat {
   const CRIT_MULT: int = 2
 
   # damage after armour, with a crit multiplier applied on an exact roll
-  @export fn damage(attack: int, armour: int, roll: int) -> int {
+  @export function damage(attack: int, armour: int, roll: int) -> int {
     var raw = attack - armour
     if raw < 1 { raw = 1 }
     if roll == 20 { raw = raw * CRIT_MULT }
@@ -25,7 +25,7 @@ program Combat {
 
   # how many hits to drop a target — the loop is here so the caller cannot
   # accidentally disagree with `damage` about rounding
-  @export fn hits_to_kill(hp: int, attack: int, armour: int) -> int {
+  @export function hits_to_kill(hp: int, attack: int, armour: int) -> int {
     var left = hp
     var n = 0
     while left > 0 {
@@ -35,12 +35,12 @@ program Combat {
     return n
   }
 
-  @export fn xp_for(level: int, kills: int) -> int {
+  @export function xp_for(level: int, kills: int) -> int {
     return curve(level) * kills
   }
 
   # private: not exported, so it is not a symbol in the library
-  fn curve(level: int) -> int {
+  function curve(level: int) -> int {
     return 10 + level * level * 3
   }
 }

examples/net_rt.ludic

@@ -14,7 +14,7 @@
 # a real socket when a program binds `extern fn net_send/net_poll`).
 
 # The authority ships one entity's authoritative synced state to peers.
-fn rt_replicate(e: int) -> void {
+function rt_replicate(e: int) -> void {
   let w = words(512)
   w[0] = e                                 # entity id in the first word
   let n = serialize(e, offset(w, 4))       # synced fields after it
@@ -23,7 +23,7 @@ fn rt_replicate(e: int) -> void {
 
 # A peer drains every inbound snapshot and applies it to the named entity. One
 # datagram per poll (the transport is datagram-preserving), so loop until empty.
-fn rt_receive() -> void {
+function rt_receive() -> void {
   let w = words(512)
   var n = net_poll(w, 2048)
   while n > 0 {

examples/snake.ludic

@@ -46,7 +46,7 @@ program Snake {
   const SHADE_SCORE:   int = 0xffe060
   const SHADE_OVER:    int = 0xff5555
 
-  fn reset(unused: int) -> int {
+  function reset(unused: int) -> int {
     for (p, s) in query [Pos, Seg] { despawn self() }
     spawn S0 { Seg { order: 0 };  Pos { x: 10, y: 7 } }
     spawn S1 { Seg { order: 1 };  Pos { x: 9,  y: 7 } }