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/emit_head.ludic

@@ -30,9 +30,49 @@ function global_init(d: Node) -> pointer {
   let e = d.a
   if e.kind == E_INT or e.kind == E_FLOAT or e.kind == E_BOOL { return itoa(e.ival) }
   if e.kind == E_UN and (e.s == ("-")) and e.a.kind == E_INT { return (("-") + itoa(e.a.ival)) }
+  if e.kind == E_MEMBER and e.a.kind == E_ID {                  # `Enum.Variant` is a compile-time int
+    let ord = enum_ordinal(e.a.s, e.s)
+    if ord >= 0 { return itoa(ord) }
+  }
   if (llty(d.ty) == "ptr") { return "null" }
   return "0"
 }
+# does a global's initializer need code at startup (anything global_init cannot fold)?
+function global_needs_init_code(d: Node) -> bool {
+  if (d.a == null) { return false }
+  let e = d.a
+  if e.kind == E_INT or e.kind == E_FLOAT or e.kind == E_BOOL or e.kind == E_NULL { return false }
+  if e.kind == E_UN and (e.s == ("-")) and e.a.kind == E_INT { return false }
+  if e.kind == E_MEMBER and e.a.kind == E_ID { if enum_ordinal(e.a.s, e.s) >= 0 { return false } }
+  return true
+}
+
+# @L_init_globals(): evaluate every global initializer global_init could not fold
+# (`var run: Progress = new Progress`, `var speed: int = BASE * 2`, a call), in
+# declaration order, once at startup — after the runtime boots, before Start.
+function emit_global_init_fn() -> void {
+  ll_t = 0;  ll_lbl = 0;  g_term = false;  loc_reset();  nloop = 0;  nself = 0
+  ret_ty = "void"
+  let fbody = buf_new()
+  falloc = buf_new()
+  let saved = code
+  code = fbody
+  var i = 0
+  while i < len(prog) {
+    let d = prog[i]
+    if d.kind == N_VAR and global_needs_init_code(d) {
+      let v = emit_expr(d.a)
+      emit("  store ");  emit(llty(d.ty));  emit(" ");  emit(coerce_code(v, d.ty));  emit(", ptr @g_");  emit(d.s);  emit("\n")
+    }
+    i = i + 1
+  }
+  emit("  ret void\n")
+  code = saved
+  emit("define void @L_init_globals() {\nentry:\n")
+  emit(buf_str(falloc))
+  emit(buf_str(fbody))
+  emit("}\n\n")
+}
 
 function emit_header() -> void {
   emith("; Ludic (self-hosted) -> LLVM IR\n")
@@ -103,6 +143,14 @@ function emit_header() -> void {
   while i < len(prog) {
     let d = prog[i]
     if d.kind == N_COMP {
+      var j = 0                                   # the same record twice would silently use the first
+      while j < i {
+        if prog[j].kind == N_COMP and (prog[j].s == d.s) {
+          if (j < g_prog_user_end) and (i >= g_prog_user_end) { perr(`property {d.s} is also a property of the engine runtime; choose another name`) }
+          perr(`property {d.s} is declared twice`)
+        }
+        j = j + 1
+      }
       emith(layout_ty(d.s));  emith(" = type { ")
       if len(d.kids) == 0 { emith("i32") }
       var f = 0
@@ -120,6 +168,14 @@ function emit_header() -> void {
   while i < len(prog) {
     let d = prog[i]
     if d.kind == N_VAR {
+      var j = 0                                   # the same name twice would be one LLVM global
+      while j < i {
+        if prog[j].kind == N_VAR and (prog[j].s == d.s) {
+          if (j < g_prog_user_end) and (i >= g_prog_user_end) { perr(`variable {d.s} is also a variable of the engine runtime; choose another name`) }
+          perr(`variable {d.s} is declared twice`)
+        }
+        j = j + 1
+      }
       emith("@g_");  emith(d.s);  emith(" = internal global ")
       emith(llty(d.ty));  emith(" ")
       emith(global_init(d))