feat(engine): #90 atlas-aware Sprite component, #91 become from listeners, 0.3.x ergonomics batch

Closes the two open issues and lands the pending unreleased batch:

- #90: `Sprite { atlas: 1 }` routes esys_sprite through atlas_draw_ex
  (scale/flip/tint), so cell / cell_span / strip ids of any size draw
  through the engine sprite-render system. examples/library/sprite_atlas
  is the pixel-readback regression.
- #91: `become` from an @On(Event) listener / global handler / plain
  function no longer segfaults the compiler; it emits @L_scene_leave()
  (a dispatch on the live scene id) so the leaving scene's on-exit runs.
  UI_* handles are readable from any code (widget table built on first
  use). examples/library/scene_menus covers it.
- fix: a windowed `ludicc -o` build that reaches the audio runtime only
  through the atlas/Assets preload import now links audio.ll +
  AVFoundation (the audio backend link was gated on a game-level
  Audio.* call, so any windowed game declaring Sprite failed to link).
- the hand-written "Unreleased" CHANGELOG section is converted to
  changesets under changes/ so `x release` generates it.
- plus the batch: engine-driven retained UI + UiClicked event, Overlay
  phase, TileSkin tilemap-render system, Key.* constants, Font/Ui/File
  namespaces, Sprite.strip, prefabs, managers, countdown fields,
  enum-typed machines, layer @Queries, ludic.prefs / ludic.dungeon
  packages, Ai.seek pathing, Solids.solid2, cursor confine (mode 3)
  fix, shooter centre-aim fix, reserved-word function diagnostic.

Verified: x test (124/124), x test-tools, check-impl, check-vocabulary,
check-docs, docs-gen + docs-check, bootstrap-cfree (seed is a fixpoint).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

selfhost/backend/game/emit_machine.ludic

@@ -12,6 +12,22 @@ function machine_var(a: Node) -> Node {
   return null
 }
 
+# the value a state dispatches on: its explicit `= expr`; else, when the machine's
+# store is a `var` declared with an enum type, the variant named like the state
+# (`var mode: HeroState` + `state Rolling` -> HeroState.Rolling); else its ordinal.
+function machine_state_value(m: Node, state: Node) -> pointer {
+  if (state.b != null) { return emit_expr(state.b).code }
+  let gv = machine_var(m.a)
+  if (gv != null) {
+    if (gv.ty != null) {
+      let ord = enum_ordinal(gv.ty, state.s)
+      if ord >= 0 { return itoa(ord) }
+      if (find_enum(gv.ty) != null) { perr(`machine state {state.s} is not a variant of enum {gv.ty}`) }
+    }
+  }
+  return itoa(state.ival)
+}
+
 function emit_machine(st: Node) -> void {
   let gv = machine_var(st.a)
   var s = ""
@@ -26,8 +42,8 @@ function emit_machine(st: Node) -> void {
   var i = 0
   while i < len(st.kids) {
     let state = st.kids[i]
-    let v = emit_expr(state.b)
-    let c = emit_bind(`icmp eq i32 {s}, {v.code}`)
+    let v = machine_state_value(st, state)
+    let c = emit_bind(`icmp eq i32 {s}, {v}`)
     let body = lbl("sbody");  let nxt = lbl("sarm")
     emit("  br i1 ");  emit(c);  emit(", label %");  emit(body);  emit(", label %");  emit(nxt);  emit("\n")
     emit(body);  emit(":\n");  g_term = false
@@ -53,19 +69,22 @@ function emit_become(st: Node) -> void {
     while i < len(m.kids) { if (m.kids[i].s == st.s) { target = m.kids[i] };  i = i + 1 }
     if (target != null) {
       let gv = machine_var(m.a)
-      let sv = emit_expr(target.b)
+      let sv = machine_state_value(m, target)
       if (gv != null) {
-        emit("  store i32 ");  emit(sv.code);  emit(", ptr @g_");  emit(m.a.s);  emit("\n")
+        emit("  store i32 ");  emit(sv);  emit(", ptr @g_");  emit(m.a.s);  emit("\n")
       } else {
         let regv = emit_expr(m.a)
-        emit("  call void @fn_rt_set_reg(i32 ");  emit(regv.code);  emit(", i32 ");  emit(sv.code);  emit(")\n")
+        emit("  call void @fn_rt_set_reg(i32 ");  emit(regv.code);  emit(", i32 ");  emit(sv);  emit(")\n")
       }
       return
     }
   }
   let sc = find_scene(st.s)                             # else a scene transition
   if (sc == null) { perr(`become: no state or scene {st.s}`) }
+  # leave the scene we are in: statically known inside a scene's own handler, else
+  # (a global handler, an event listener, a function) whichever scene is live now
   if (g_cur_scene != null) { emit("  call void @scene_exit_");  emit(g_cur_scene.s);  emit("()\n") }
+  else { emit("  call void @L_scene_leave()\n") }
   emit("  store i32 ");  emit(itoa(sc.ival));  emit(", ptr @L_scene\n")
   emit("  call void @scene_enter_");  emit(sc.s);  emit("()\n")
 }