feat(ring,api): pick destination clip then resolve matching chained morph

Tasks 3-6. Transition is now a directed clip-pair morph; ScaleRing.morph_for
looks up (from,to)->file. advance_ring returns structural steps (no file);
resolve_move picks each crossed altitude's clip THEN its morph, chained, and
reports the locked target. Fast spin keeps the whole chain (blended) instead
of collapsing. /api/ring/advance takes from_clip_id, draws picks, returns the
resolved chain. Dropped ring_move_to_dict + _rev_file.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

simulator/clips.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from player.ring import RingMove, Scale, ScaleRing, Transition, scale_at
+from player.ring import ResolvedMove, RingMove, Scale, ScaleRing, Transition
 
 
 @dataclass(frozen=True)
@@ -99,7 +99,12 @@ def load_ring(path: str | Path) -> ScaleRing | None:
         return None
     scales = tuple(_scale_from_dict(s) for s in ring.get("scales", []))
     transitions = tuple(
-        Transition(file=t["file"], model=t.get("model", ""))
+        Transition(
+            from_clip=t.get("from", ""),
+            to_clip=t.get("to", ""),
+            file=t["file"],
+            model=t.get("model", ""),
+        )
         for t in ring.get("transitions", [])
     )
     return ScaleRing(scales=scales, transitions=transitions)
@@ -127,35 +132,35 @@ def ring_to_dict(ring: ScaleRing, clips: list[Clip]) -> dict:
             }
             for s in ring.scales
         ],
-        "transitions": [{"file": t.file, "model": t.model} for t in ring.transitions],
+        "transitions": [
+            {"from": t.from_clip, "to": t.to_clip, "file": t.file, "model": t.model}
+            for t in ring.transitions
+        ],
     }
 
 
-def ring_move_to_dict(
-    move: RingMove, ring: ScaleRing, chosen_clip_id: str | None = None
-) -> dict:
-    """JSON form of an encoder move: the landing scale's clip and the ordered
-    transition clips to play (with direction). `fast` flags a collapsed fast-spin
-    pass; the single step then carries `blended` so the renderer plays it quick.
+def resolved_move_to_dict(move: RingMove, resolved: ResolvedMove) -> dict:
+    """JSON form of a RESOLVED encoder move: where it lands, the locked clip, and
+    the ordered chained morphs. Each step carries the clip it morphs FROM (the
+    clip currently shown), the chosen clip it morphs TO, and the matching morph
+    file (None if no morph was baked — the renderer plain-cuts). `fast` marks a
+    fast spin; each step then carries `blended` so the renderer accelerates it.
 
-    `target_clip_id` is the pool member the player should load on landing. The
-    caller passes the random pick (`pick_clip_id(landed_scale, random.random())`,
-    content-pipeline §11.1); when omitted it falls back to the scale's primary
-    `clip_id` (deterministic — keeps pre-pool callers/tests working)."""
+    `target_clip_id` is the final clip the viewer locks onto."""
     return {
         "from_index": move.from_index,
         "to_index": move.to_index,
         "wrapped": move.wrapped,
         "fast": move.fast,
-        "target_clip_id": chosen_clip_id or scale_at(ring, move.to_index).clip_id,
+        "target_clip_id": resolved.target_clip_id,
         "steps": [
             {
-                "edge": st.edge,
-                "reversed": st.reversed,
-                "file": st.file,
-                "to_index": st.to_index,
-                "blended": st.blended,
+                "from_clip": s.from_clip,
+                "to_clip": s.to_clip,
+                "file": s.file,
+                "to_index": s.to_index,
+                "blended": s.blended,
             }
-            for st in move.steps
+            for s in resolved.steps
         ],
     }