Baseline: Ludic compiler + toolchain, Phase 1 syntax fixes complete

Self-hosted compiler (selfhost/*.ludic), runtime, examples, editor tooling,
and docs. Phase 1 of the syntax-redesign cohesion pass has landed:
edge-system fix, signature-query, when-alias, and the documentation truth-pass.
Suite green (14/14), C-free bootstrap fixpoint holds.

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

selfhost/emit_decl.ludic

@@ -0,0 +1,104 @@
+# emit_decl.ludic — functions, main, and the whole-program driver. A function's
+# body is built into a scratch buffer so entry-block allocas can be spliced in
+# ahead of it (see emit_alloca). Returns go through a %retval slot + `ret` label.
+
+fn emit_params_sig(d: Node) -> void {
+  let i = 0
+  while i < len(d.kids) {
+    if i > 0 { emit(", ") }
+    emit(llty(d.kids[i].ty))  emit(" %arg_")  emit(d.kids[i].s)
+    i = i + 1
+  }
+}
+
+fn emit_fn(d: Node) -> void {
+  ll_t = 0  ll_lbl = 0  g_term = false  loc_reset()  nloop = 0
+  ret_ty = d.ty
+  let fbody = buf_new()
+  falloc = buf_new()
+  let saved = code
+  code = fbody
+  let rl = llty(ret_ty)
+  if not streq(rl, "void") { buf_puts(falloc, "  %retval = alloca ")  buf_puts(falloc, rl)  buf_puts(falloc, "\n") }
+  # params: store each incoming argument into a stack slot
+  let i = 0
+  while i < len(d.kids) {
+    let p = d.kids[i]
+    let slot = emit_alloca(llty(p.ty))
+    emit("  store ")  emit(llty(p.ty))  emit(" %arg_")  emit(p.s)  emit(", ptr ")  emit(slot)  emit("\n")
+    loc_push(p.s, slot, p.ty)
+    i = i + 1
+  }
+  emit_block(d.a)
+  if not g_term { emit("  br label %ret\n") }
+  emit("ret:\n")
+  if streq(rl, "void") { emit("  ret void\n") }
+  else { let r = emit_bind(sconcat("load ", sconcat(rl, ", ptr %retval")))  emit("  ret ")  emit(rl)  emit(" ")  emit(r)  emit("\n") }
+  code = saved
+  emit("define ")  emit(rl)  emit(" @fn_")  emit(d.s)  emit("(")  emit_params_sig(d)  emit(") {\nentry:\n")
+  emit(buf_str(falloc))
+  emit(buf_str(fbody))
+  emit("}\n\n")
+}
+
+fn emit_main(d: Node) -> void {
+  ll_t = 0  ll_lbl = 0  g_term = false  loc_reset()  nloop = 0
+  ret_ty = "int"
+  let fbody = buf_new()
+  falloc = buf_new()
+  let saved = code
+  code = fbody
+  buf_puts(falloc, "  %retval = alloca i32\n")
+  emit("  store i32 %argc, ptr @L_argc\n")
+  emit("  store ptr %argv, ptr @L_argv\n")
+  emit("  store i32 0, ptr %retval\n")
+  emit_block(d.a)
+  if not g_term { emit("  br label %ret\n") }
+  emit("ret:\n")
+  let r = emit_bind("load i32, ptr %retval")
+  emit("  ret i32 ")  emit(r)  emit("\n")
+  code = saved
+  emit("define i32 @main(i32 %argc, ptr %argv) {\nentry:\n")
+  emit(buf_str(falloc))
+  emit(buf_str(fbody))
+  emit("}\n")
+}
+
+fn emit_program() -> void {
+  head = buf_new()
+  code = buf_new()
+  loc_name = new []ptr  loc_reg = new []ptr  loc_ty = new []ptr
+  brk_lbl = new []ptr   cnt_lbl = new []ptr
+  self_stk = new []ptr
+  mach_stk = new []Node
+  emit_header()
+  if has_ecs() { emit_ecs_storage() }
+  let i = 0
+  while i < len(prog) { if prog[i].kind == N_FN { emit_fn(prog[i]) }  i = i + 1 }
+  if has_ecs() { emit_ecs_allocator()  emit_snapshot() }
+  if has_ui() { emit_ui_build() }
+  if has_systems() { emit_game_main() }
+  else {
+    i = 0
+    while i < len(prog) { if prog[i].kind == N_MAIN { emit_main(prog[i]) }  i = i + 1 }
+  }
+}
+
+# Flush the emitted IR. With a null path it goes to stdout (the pipe the shell
+# drivers read); with a path it is written to that file so ludicc can hand it to
+# clang itself.
+fn ir_flush(path: ptr) -> bool {
+  let h = buf_str(head)
+  let c = buf_str(code)
+  if ptr_is_null(path) {
+    print_str(h)
+    print_str(c)
+    return true
+  }
+  let f = file_open(path, "wb")
+  if ptr_is_null(f) { return false }
+  file_write(f, h, slen(h))
+  file_write(f, c, slen(c))
+  file_close(f)
+  return true
+}