feat(types): add Reflect.* — runtime reflection over the world schema (#20)

Runtime type reflection: enumerate properties and fields by index, resolve ids
by name, read a field's type, and get/set/has an entity's fields generically —
the foundation the issue calls out for auto-serialization, data-driven tools,
and debug/inspector overlays. Built on the existing EV2 reflection ABI plus a
new EV8 metadata-enumeration layer, all generated at compile time (a table walk,
no heavy runtime introspection), so a binary that never reflects pays nothing.

Surface (Reflect.*, aliased in emit_call.ludic over the world_* reflection ABI):
  - Reflect.prop(name) / field(prop,name)        resolve ids by name (-1 = none)
  - Reflect.prop_count() / prop_name(i)          enumerate properties
  - Reflect.field_count(prop) / field_name(prop,i) / field_type(prop,i)
                                                 enumerate a component's fields
  - Reflect.get / set / has (entity, prop, ...)  read/write/test a field by id
  - Reflect.kind(entity) / model(name)           an entity's model, by id/name

New codegen (emit_world.ludic, EV8): ludic_prop_count / prop_name /
field_count / field_name / field_type, generated the same way as ludic_prop_id
— a switch over the compile-time property/field metadata, falling through to the
mod-registered (dynamic) registries. Field names/types come straight from the
AST, so field_type reports the declared type ("int"/"fixed"/…). A program that
uses Reflect.* force-emits the reflection ABI (g_uses_reflect) so it needs no
@events of its own, exactly like Query.* (#42).

examples/library/reflect.ludic asserts 20 cases including a generic inspector
that sums every field of every component an entity has while naming none of them
— the auto-save / debug-overlay pattern end to end. Wired into x test (now 64
passed). Docs: a Reflect section + 12 per-symbol pages (positioned as an
advanced/tooling surface), inventory/coverage green. Seed reseeded; the C-free
bootstrap fixpoint holds.

Scope: this lands the reflection core and a real consumer (the generic
inspector). The generic value-tree `serialize` the proposal also sketches wants
a tagged-union/any value type from the #1 type-system work, so it is tracked as
a follow-up rather than forced in here.

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

selfhost/backend/emit_call.ludic

@@ -234,6 +234,24 @@ function emit_ns_call(ns: pointer, meth: pointer, e: Node) -> Val {
     if (meth == "nearest") { bare = "query_nearest"; push(labels, "prop"); push(labels, "pos"); push(labels, "x_field"); push(labels, "y_field"); push(labels, "x"); push(labels, "y") }
     if (meth == "within")  { bare = "query_within";  push(labels, "prop"); push(labels, "pos"); push(labels, "x"); push(labels, "y"); push(labels, "radius"); push(labels, "x_field"); push(labels, "y_field") }
   }
+  # Reflect.* — runtime type reflection over the world schema (the EV2/EV8 ABI).
+  # Enumerate properties and fields by index, resolve ids by name, and read/write
+  # a field by (prop, field) id — the foundation for auto-serialization and debug
+  # inspectors. Reads the same generated metadata a foreign mod binds.
+  if (ns == "Reflect") {
+    if (meth == "prop")        { bare = "world_prop_id";     push(labels, "name") }
+    if (meth == "field")       { bare = "world_field_id";    push(labels, "prop"); push(labels, "name") }
+    if (meth == "prop_count")  { bare = "world_prop_count" }
+    if (meth == "prop_name")   { bare = "world_prop_name";   push(labels, "index") }
+    if (meth == "field_count") { bare = "world_field_count"; push(labels, "prop") }
+    if (meth == "field_name")  { bare = "world_field_name";  push(labels, "prop"); push(labels, "index") }
+    if (meth == "field_type")  { bare = "world_field_type";  push(labels, "prop"); push(labels, "index") }
+    if (meth == "get")         { bare = "world_get";         push(labels, "entity"); push(labels, "prop"); push(labels, "field") }
+    if (meth == "set")         { bare = "world_set";         push(labels, "entity"); push(labels, "prop"); push(labels, "field"); push(labels, "value") }
+    if (meth == "has")         { bare = "world_has";         push(labels, "entity"); push(labels, "prop") }
+    if (meth == "kind")        { bare = "world_kind";        push(labels, "entity") }
+    if (meth == "model")       { bare = "world_model_id";    push(labels, "name") }
+  }
   if (bare == null) { perr(`unknown builtin {ns}.{meth}`) }
   reorder_named(e, labels)
   let id = node(E_ID); id.s = bare; e.a = id
@@ -378,6 +396,12 @@ function emit_call(e: Node) -> Val {
   if (name == "world_attach_dyn") { let a = emit_expr(e.kids[0]);  let b = emit_expr(e.kids[1]);  emit("  call void @ludic_attach_dyn(i32 ");  emit(a.code);  emit(", i32 ");  emit(b.code);  emit(")\n");  return val("0", "void") }
   if (name == "world_detach_dyn") { let a = emit_expr(e.kids[0]);  let b = emit_expr(e.kids[1]);  emit("  call void @ludic_detach_dyn(i32 ");  emit(a.code);  emit(", i32 ");  emit(b.code);  emit(")\n");  return val("0", "void") }
   if (name == "world_spawn") { let a = emit_expr(e.kids[0]);  return val(emit_bind(`call i32 @ludic_spawn(i32 {a.code})`), "int") }
+  # EV8 — schema enumeration, walking property/field metadata by index (Reflect.*).
+  if (name == "world_prop_count") { return val(emit_bind("call i32 @ludic_prop_count()"), "int") }
+  if (name == "world_prop_name") { let a = emit_expr(e.kids[0]);  return val(emit_bind(`call ptr @ludic_prop_name(i32 {a.code})`), "string") }
+  if (name == "world_field_count") { let a = emit_expr(e.kids[0]);  return val(emit_bind(`call i32 @ludic_field_count(i32 {a.code})`), "int") }
+  if (name == "world_field_name") { let a = emit_expr(e.kids[0]);  let b = emit_expr(e.kids[1]);  return val(emit_bind(`call ptr @ludic_field_name(i32 {a.code}, i32 {b.code})`), "string") }
+  if (name == "world_field_type") { let a = emit_expr(e.kids[0]);  let b = emit_expr(e.kids[1]);  return val(emit_bind(`call ptr @ludic_field_type(i32 {a.code}, i32 {b.code})`), "string") }
   if is_intrinsic(name) { return emit_intrinsic(name, e) }
   if is_intrinsic2(name) { return emit_intrinsic2(name, e) }
   if is_math_builtin(name) { return emit_math_builtin(name, e) }