feat(stdlib): namespaced standard library (issue #2)

Implement the bulk of the namespaced-stdlib proposal (workshopsoft/ludic#2):
156 namespace methods across Math, Text, List, Ease, Collide, World, Net,
Sys, Save, Mem, extended Screen, Color functions, extended Random, and Time.
All deterministic fixed-point; self-hosting (C-free bootstrap fixpoint holds).

Compiler (selfhost/):
- Math.*: sqrt/sin/cos/tan/atan2/asin/acos (fixed-point runtime prelude —
  bit-by-bit isqrt, 256-entry interpolated sine table, Ross atan2), plus
  hypot/dist/dist2/deg_to_rad/rad_to_deg/posmod/wrap/ping_pong/snapped/
  move_toward/smoothstep/lerp/remap/sign/floor/ceil/round.
- Text.* (complete): upper/lower/trim/repeat/pad, split/join/replace,
  and the libc-backed queries.
- List.* (complete): insert/remove_at/remove/sort plus the earlier ops.
- Ease.* (in/out/in_out/back/bounce) and Collide.* (rects/point_rect/
  circles/rect_circle).
- Phase 3: World/Net/Sys/Save namespaced over the bare builtins (byte-
  identical IR) and Mem.* (bytes/words/copy/fill/peek/poke).
- Screen.* extended (line/circle/fill_circle/triangle/fill_triangle via new
  runtime primitives; sprite/sprite_scaled aliases), Color.* functions,
  Random.* (value/int/sign), Time.* (frame/delta/elapsed/now — new
  game-loop frame counter).
- Fix a lexer bug: fixed-point literals with >4 fractional digits overflowed.

Docs & tooling:
- 129 new per-symbol doc pages; gen.py made data-driven (namespaces
  discovered from the docs, no hardcoded list); new check-impl.py enforces
  that every implemented namespace method / keyword / type / phase has a
  doc page, wired into `x test-tools`. Document the previously-undocumented
  keywords (break/continue/where/entry/new/public + and/or/not tokens).
- LSP: namespaced signature help (ns_method_sig) covering every namespace.

Tests: 12 new self-host/regression tests + a golden render for the drawing
primitives. All suites green (selfhost 21, regression 45, tools 29).

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

selfhost/emit_mem.ludic

@@ -0,0 +1,48 @@
+# emit_mem.ludic — the Mem.* namespace: raw buffers and byte pokes. bytes/words
+# allocate (as the bare builtins do); copy/fill wrap memcpy/memset; peek/poke
+# read and write one byte. The low-level escape hatch, PICO-8's memcpy/memset/
+# peek/poke by another name.
+
+fn is_mem_ns(meth: ptr) -> bool {
+  if (meth == "bytes") or (meth == "words") { return true }
+  if (meth == "copy") or (meth == "fill") or (meth == "peek") or (meth == "poke") { return true }
+  return false
+}
+
+fn emit_mem_ns(meth: ptr, e: Node) -> Val {
+  if (meth == "bytes") {                            # allocate n bytes -> a byte buffer
+    let n = emit_expr(e.kids[0])
+    let w = emit_bind(`zext i32 {n.code} to i64`)
+    return val(emit_bind(`call ptr @malloc(i64 {w})`), "ptr")
+  }
+  if (meth == "words") {                            # allocate n 32-bit words
+    let n = emit_expr(e.kids[0])
+    let by = emit_bind(`mul i32 {n.code}, 4`)
+    let w = emit_bind(`zext i32 {by} to i64`)
+    return val(emit_bind(`call ptr @malloc(i64 {w})`), "words")
+  }
+  if (meth == "copy") {                             # copy n bytes src -> dst
+    let dst = emit_expr(e.kids[0]);  let src = emit_expr(e.kids[1]);  let n = emit_expr(e.kids[2])
+    let w = emit_bind(`zext i32 {n.code} to i64`)
+    emit("  call ptr @memcpy(ptr ");  emit(dst.code);  emit(", ptr ");  emit(src.code);  emit(", i64 ");  emit(w);  emit(")\n")
+    return val("0", "void")
+  }
+  if (meth == "fill") {                             # set n bytes of buf to value v
+    let buf = emit_expr(e.kids[0]);  let v = emit_expr(e.kids[1]);  let n = emit_expr(e.kids[2])
+    let w = emit_bind(`zext i32 {n.code} to i64`)
+    emit("  call ptr @memset(ptr ");  emit(buf.code);  emit(", i32 ");  emit(v.code);  emit(", i64 ");  emit(w);  emit(")\n")
+    return val("0", "void")
+  }
+  if (meth == "peek") {                             # read one byte at buf[i], 0..255
+    let buf = emit_expr(e.kids[0]);  let i = emit_expr(e.kids[1])
+    let p = emit_bind(`getelementptr inbounds i8, ptr {buf.code}, i32 {i.code}`)
+    let c = emit_bind(`load i8, ptr {p}`)
+    return val(emit_bind(`zext i8 {c} to i32`), "int")
+  }
+  # poke: write the low byte of v at buf[i]
+  let buf = emit_expr(e.kids[0]);  let i = emit_expr(e.kids[1]);  let v = emit_expr(e.kids[2])
+  let p = emit_bind(`getelementptr inbounds i8, ptr {buf.code}, i32 {i.code}`)
+  let b = emit_bind(`trunc i32 {v.code} to i8`)
+  emit("  store i8 ");  emit(b);  emit(", ptr ");  emit(p);  emit("\n")
+  return val("0", "void")
+}