feat(anim): animation ergonomics — named clips, Anim.play/Motion.to, frame events, fluent Tween handles (#48)

The ergonomic layer over the engine-owned SpriteAnim/Motion systems (#43):

- Named clips: Anim.clip("run", frames, fps, mode) registers a clip by name and
  Anim.play(entity, "run") plays it; Anim.play(entity, fps, frames, mode) sets
  the clip directly. A name-keyed registry in systems.ludic.
- Frame events: Anim.on_frame(entity, frame) arms optional SpriteAnim
  event_frame/event_fired fields; the engine flags the tick the clip first lands
  on that frame, and Anim.fired(entity) reads it — the game reacts, so it stays
  inside the no-runtime-dispatch event model.
- Motion.to(entity, from, to, dur, ease) starts a value tween over the Motion
  component in one call (reflection-ABI writes, resetting the timer).
- Fluent Tween handles (runtime/native/tween.ludic): Tween.to / Tween.chain /
  Tween.delay build a sequenced, disposable handle advanced by a new engine-owned
  system (esys_tween, run each Update tick); Tween.value / Tween.done /
  Tween.parallel / Tween.stop read and control it. The 1-arg Tween.done(handle)
  is disambiguated from the 2-arg pure Tween.done(timer, dur).

Splicing: g_uses_anim_rt pulls in systems.ludic; g_uses_tween_rt pulls in
tween.ludic and inserts esys_tween into the Update phase. All integer and
deterministic, so animation and motion reproduce exactly under replay/lockstep.

Worked example + regression: examples/library/anim_sugar.ludic
(4 8 2 1 0 100 100 0 0 1 20 20 30 0 1). Twelve new docs pages (Anim, the new
Motion namespace, Tween handles). Full suite 77 passed, self-host C-free fixpoint
intact, no golden drift.

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

LANGUAGE.md

@@ -268,7 +268,7 @@ enough, and a game that declares none is byte-for-byte unchanged.
 
 | Component | Phase | Effect |
 |---|---|---|
-| `SpriteAnim { ticks, fps, frames, mode, frame }` | `Update` | advances `frame` — spritesheet frame animation (`mode` 0 loop, 1 once, 2 ping-pong) |
+| `SpriteAnim { ticks, fps, frames, mode, frame }` | `Update` | advances `frame` — spritesheet frame animation (`mode` 0 loop, 1 once, 2 ping-pong). Optional `event_frame`/`event_fired` fields arm a frame event (`Anim.on_frame` / `Anim.fired`) |
 | `Motion { ticks, dur, from, to, ease, value, done }` | `Update` | advances `value` — value tween (`ease` 0 linear, 1 in, 2 out, 3 in-out), latches `done` |
 | `Light2D { x, y, radius, color, intensity }` | `Render` | additive radial glow; the engine runs the whole 2D light pass and presents. Optional `direction`/`spread` (cone), `falloff`, `softness`, `gel` fields select the render-quality tiers |
 | `Occluder { x, y, w, h }` | `Render` | a rectangular shadow caster the light pass carves out |
@@ -282,6 +282,15 @@ model Hero { Pos, SpriteAnim }
 spawn Hero { Pos { x: 0, y: 0 }  SpriteAnim { fps: 10, frames: 6, mode: 0 } }
 ```
 
+An **ergonomic layer** sits over the animation components: register named clips
+with `Anim.clip("run", frames, fps, mode)` and (re)start one with
+`Anim.play(entity, "run")` (or `Anim.play(entity, fps, frames, mode)`); arm frame
+events with `Anim.on_frame` / read them with `Anim.fired`; start a value tween in
+one call with `Motion.to(entity, from, to, dur, ease)`. Standalone **fluent tween
+handles** — `Tween.to` / `Tween.chain` / `Tween.delay`, read with `Tween.value` /
+`Tween.done` / `Tween.parallel` and cancelled with `Tween.stop` — sequence
+multi-step motion the engine advances each tick, beyond a single `Motion`.
+
 A `Light2D` / `Occluder` reads its position from a `Position { x, y }` component
 on the same entity when the entity carries one, else from its own `x` / `y`
 fields — so "Position + Light2D" and a self-positioned light both work. With