Lifecycle hooks: @OnStart/@OnQuit, @OnDespawn, @OnAttach (like @OnSpawn)

Adds the rest of the game/entity/property lifecycle as @-hooks, each firing at
one timeline moment and reducing to ordinary code:

- @OnStart / @OnQuit (program): @OnStart aliases the Start phase; @OnQuit runs in
  the frame loop's done: block, after the loop stops and before teardown.
- @OnDespawn(Model) (entity): a destructor. Despawn doesn't statically know the
  entity's model, so hooks compile to @on_despawn_<Model>(entity) functions and
  emit_despawn dispatches on @L_kind. Symmetric with @OnSpawn.
- @OnAttach(Property): fires in emit_init_component once a property is attached
  and seeded, with the property bound by name.

Registries + parsing mirror @OnSpawn. examples/lifecycle.ludic narrates the whole
timeline (output 1 700 50 950 2). Behaviour-preserving (goldens byte-identical,
despawn users unaffected when no hooks registered); test.sh 16/16, fixpoint holds.

Deferred: @OnDetach (per-property runtime dispatch) and scene @OnEnter/@OnExit
(need scene support in the compiler).

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

selfhost/emit_core.ludic

@@ -176,6 +176,29 @@ fn onspawn_body(model: ptr) -> Node {
   return ptr_null()
 }
 
+# @OnDespawn(Model): a Model -> hook-body registry. Despawn does not statically
+# know an entity's model, so these are emitted as functions and dispatched on the
+# entity's kind at each `despawn`. @OnAttach(Property) fires per property-attach.
+var g_ondespawn: []Node         # each: s = Model name, a = hook body block
+var g_onattach: []Node          # each: s = Property name, a = hook body block
+
+fn register_ondespawn(model: ptr, body: Node) -> void {
+  let n = node(N_BLOCK); n.s = model; n.a = body; push(g_ondespawn, n)
+}
+fn ondespawn_body(model: ptr) -> Node {
+  let i = 0
+  while i < len(g_ondespawn) { if streq(g_ondespawn[i].s, model) { return g_ondespawn[i].a };  i = i + 1 }
+  return ptr_null()
+}
+fn register_onattach(prop: ptr, body: Node) -> void {
+  let n = node(N_BLOCK); n.s = prop; n.a = body; push(g_onattach, n)
+}
+fn onattach_body(prop: ptr) -> Node {
+  let i = 0
+  while i < len(g_onattach) { if streq(g_onattach[i].s, prop) { return g_onattach[i].a };  i = i + 1 }
+  return ptr_null()
+}
+
 # local variable environment
 fn loc_reset() -> void { nloc = 0 }
 fn loc_push(name: ptr, r: ptr, ty: ptr) -> void {