refactor(selfhost): reorganise into concern-based subdirectories

Split the flat 38-file selfhost/ into concern-based subdirectories:

  frontend/        lex, parse, parse_game, ast
  support/         str, buf, io
  backend/         core IR + expression/statement lowering
  backend/game/    ECS/scene/event/world lowering
  backend/stdlib/  the namespaced Math.*/Text.*/Crypto.*/… intrinsics

and split the three oversized emitters at responsibility boundaries so
no file mixes concerns:

  emit_game.ludic  -> + emit_world.ludic         (reflection world table,
                                                  tick helpers, @main synthesis)
  emit_expr.ludic  -> + emit_call.ludic          (namespaced builtins, call
                                                  lowering, expr dispatch)
  emit_text.ludic  -> + emit_text_prelude.ludic  (emitted string-builder runtime)

FRAGS in tools/x/selfhost.ludic is updated to the new paths with the link
order preserved, and the Python doc/vocabulary tooling is updated to walk
the new layout. Because the build is a plain in-order concatenation and
every split lands on a blank-line boundary, the regenerated seed is
byte-identical: `x reseed` leaves selfhost/ludicc.seed.ll unchanged,
`x bootstrap-cfree` still reaches its fixed point, and both `x test` (56)
and `x selfhost-test` (29, incl. golden renders) stay green.

Closes #29

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

selfhost/backend/emit_new.ludic

@@ -0,0 +1,93 @@
+# emit_new.ludic — heap construction and slice operations: `new S`, `new []T`,
+# push(slice, v) and len(slice). Slices are a { data, len, cap } header the
+# holder points at, so growth is visible to every holder.
+
+function emit_sizeof(llt: pointer) -> pointer {
+  let p = emit_bind(`getelementptr {llt}, ptr null, i32 1`)
+  return emit_bind(`ptrtoint ptr {p} to i64`)
+}
+
+function emit_new_struct(name: pointer) -> Val {
+  let s = layout_node(name)                     # a struct or a property — same shape
+  if (s == null) { perr("unknown record type in new") }
+  let lty = layout_ty(name)
+  let sz = emit_sizeof(lty)
+  let obj = emit_bind(`call ptr @malloc(i64 {sz})`)
+  var f = 0
+  while f < len(s.kids) {
+    let fd = s.kids[f]
+    let addr = nreg()
+    emit("  ");  emit(addr);  emit(" = getelementptr inbounds ");  emit(lty)
+    emit(", ptr ");  emit(obj);  emit(", i32 0, i32 ");  emit(itoa(f));  emit("\n")
+    let lt = llty(fd.ty)
+    var v = "0"
+    if (lt == "ptr") { v = "null" }
+    if (fd.a != null) { let dv = emit_expr(fd.a);  v = dv.code }
+    emit("  store ");  emit(lt);  emit(" ");  emit(v);  emit(", ptr ");  emit(addr);  emit("\n")
+    f = f + 1
+  }
+  return val(obj, name)
+}
+
+function emit_new_slice(ty: pointer) -> Val {
+  let sz = emit_sizeof("%LSlice")
+  let h = emit_bind(`call ptr @malloc(i64 {sz})`)
+  let d0 = nreg();  emit("  ");  emit(d0);  emit(" = getelementptr inbounds %LSlice, ptr ");  emit(h);  emit(", i32 0, i32 0\n")
+  emit("  store ptr null, ptr ");  emit(d0);  emit("\n")
+  let d1 = nreg();  emit("  ");  emit(d1);  emit(" = getelementptr inbounds %LSlice, ptr ");  emit(h);  emit(", i32 0, i32 1\n")
+  emit("  store i32 0, ptr ");  emit(d1);  emit("\n")
+  let d2 = nreg();  emit("  ");  emit(d2);  emit(" = getelementptr inbounds %LSlice, ptr ");  emit(h);  emit(", i32 0, i32 2\n")
+  emit("  store i32 0, ptr ");  emit(d2);  emit("\n")
+  return val(h, ty)
+}
+
+function slice_field(h: pointer, i: int) -> pointer {
+  let r = nreg()
+  emit("  ");  emit(r);  emit(" = getelementptr inbounds %LSlice, ptr ");  emit(h)
+  emit(", i32 0, i32 ");  emit(itoa(i));  emit("\n")
+  return r
+}
+
+function emit_len(e: Node) -> Val {
+  let s = emit_expr(e.kids[0])
+  if is_slice_ty(s.ty) {                          # a slice: read its header length
+    let lp = slice_field(s.code, 1)
+    return val(emit_bind(`load i32, ptr {lp}`), "int")
+  }
+  let r = emit_bind(`call i64 @strlen(ptr {s.code})`)   # a string: byte length
+  return val(emit_bind(`trunc i64 {r} to i32`), "int")
+}
+
+function emit_push(e: Node) -> Val {
+  let s = emit_expr(e.kids[0])
+  let el = slice_elem(s.ty)
+  let elt = llty(el)
+  let h = s.code
+  let lp = slice_field(h, 1);  let cp = slice_field(h, 2);  let dp = slice_field(h, 0)
+  let l = emit_bind(`load i32, ptr {lp}`)
+  let c = emit_bind(`load i32, ptr {cp}`)
+  let full = emit_bind(`icmp sge i32 {l}, {c}`)
+  let grow = lbl("grow");  let put = lbl("put")
+  emit("  br i1 ");  emit(full);  emit(", label %");  emit(grow);  emit(", label %");  emit(put);  emit("\n")
+  emit(grow);  emit(":\n")
+  let dbl = emit_bind(`mul i32 {c}, 2`)
+  let isz = emit_bind(`icmp eq i32 {c}, 0`)
+  let nc = emit_bind(`select i1 {isz}, i32 8, i32 {dbl}`)
+  let esz = emit_sizeof(elt)
+  let ncw = emit_bind(`zext i32 {nc} to i64`)
+  let bytes = emit_bind(`mul i64 {ncw}, {esz}`)
+  let old = emit_bind(`load ptr, ptr {dp}`)
+  let nd = emit_bind(`call ptr @realloc(ptr {old}, i64 {bytes})`)
+  emit("  store ptr ");  emit(nd);  emit(", ptr ");  emit(dp);  emit("\n")
+  emit("  store i32 ");  emit(nc);  emit(", ptr ");  emit(cp);  emit("\n")
+  emit("  br label %");  emit(put);  emit("\n")
+  emit(put);  emit(":\n")
+  let v = emit_expr(e.kids[1])
+  let data = emit_bind(`load ptr, ptr {dp}`)
+  let slot = nreg()
+  emit("  ");  emit(slot);  emit(" = getelementptr inbounds ");  emit(elt);  emit(", ptr ");  emit(data);  emit(", i32 ");  emit(l);  emit("\n")
+  emit("  store ");  emit(elt);  emit(" ");  emit(v.code);  emit(", ptr ");  emit(slot);  emit("\n")
+  let l1 = emit_bind(`add i32 {l}, 1`)
+  emit("  store i32 ");  emit(l1);  emit(", ptr ");  emit(lp);  emit("\n")
+  return val("0", "void")
+}