feat(anim): dead-reckoning remote entity positions

Before: remote characters stutter-hop between UpdatePosition broadcasts
(typical 100-200ms interval), looking lagging-forward during continuous
motion. The retail client hides this gap by integrating velocity forward
each tick — apply_current_movement in chunk_00520000.c L7132-L7189,
mirrored by holtburger's project_pose_by_velocity in spatial/physics.rs.

Strategy:

1. RemoteDeadReckonState per remote entity tracks the last authoritative
   server position + rotation, an EMA-smoothed observed velocity from
   position deltas, and any server-supplied HasVelocity vector.

2. OnLivePositionUpdated: on each UpdatePosition arrival, snap the entity
   to the server position, then update the dead-reckon state. The
   observed-velocity is a 50/50 EMA against the running average so a
   single jitter sample doesn't blow out the velocity.

3. TickAnimations: each tick, for every remote entity in a locomotion
   cycle, integrate Entity.Position += worldVelocity * dt. World velocity
   is pulled in priority order:
     - Sequencer's MotionData.Velocity rotated by Entity.Rotation (the
       primary source; matches MotionData's "world-space on the object"
       convention per r03 §1.3)
     - Server-supplied HasVelocity from UpdatePosition (already world-space)
     - EMA-observed position-delta velocity (fallback for NPC motion
       tables with HasVelocity=0)

4. Cap: if the predicted position drifts more than velocity ×
   DeadReckonMaxPredictSeconds (1.0s) from the last server position,
   clamp back toward the server. This prevents runaway when sequencer
   velocity and server reality disagree (e.g. server rubber-banding).

Result: remote chars now move smoothly between position updates,
matching the retail client's visual feel. When UpdatePosition arrives
the entity snaps to the authoritative position and the dead-reckon
origin resets, so there's no accumulating drift.

Tests: CurrentVelocity_ScalesWithSpeedMod — new unit test verifying
that the sequencer's CurrentVelocity accurately reflects speedMod changes
across both SetCycle's rebuild path and its rescale path. Combined with
the existing MultiplyCyclicFramerate tests, this validates the
downstream-visible velocity surface the dead-reckoner reads. 633 tests
green (was 632).

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

tests/AcDream.Core.Tests/Physics/AnimationSequencerTests.cs

@@ -1102,6 +1102,51 @@ public sealed class AnimationSequencerTests
         Assert.Equal(cursorMid, GetFramePosition(seq), 5);
     }
 
+    [Fact]
+    public void CurrentVelocity_ScalesWithSpeedMod()
+    {
+        // A RunForward motion with MotionData.Velocity = (0,4,0) should
+        // surface as (0,4,0) at speedMod=1.0, (0,6,0) at 1.5×, (0,2,0) at
+        // 0.5×. The dead-reckoning integrator in TickAnimations reads
+        // CurrentVelocity each tick, so this has to be accurate.
+        const uint Style  = 0x003Du;
+        const uint Motion = 0x0007u;
+        const uint AnimId = 0x03000405u;
+
+        var anim = Fixtures.MakeAnim(4, 1, Vector3.Zero, Quaternion.Identity);
+        var setup = Fixtures.MakeSetup(1);
+        var mt = new MotionTable();
+        mt.DefaultStyle = (DRWMotionCommand)Style;
+        int cycleKey = (int)((Style << 16) | (Motion & 0xFFFFFFu));
+
+        var md = new MotionData { Flags = MotionDataFlags.HasVelocity, Velocity = new Vector3(0, 4, 0) };
+        QualifiedDataId<Animation> qid = AnimId;
+        md.Anims.Add(new AnimData
+        {
+            AnimId    = qid,
+            LowFrame  = 0,
+            HighFrame = -1,
+            Framerate = 10f,
+        });
+        mt.Cycles[cycleKey] = md;
+
+        var loader = new FakeLoader();
+        loader.Register(AnimId, anim);
+
+        var seq = new AnimationSequencer(setup, mt, loader);
+        seq.SetCycle(Style, Motion, speedMod: 1f);
+        Assert.Equal(4f, seq.CurrentVelocity.Y, 3);
+
+        // Start a fresh sequencer so the initial SetCycle applies speedMod.
+        var seq2 = new AnimationSequencer(setup, mt, loader);
+        seq2.SetCycle(Style, Motion, speedMod: 1.5f);
+        Assert.Equal(6f, seq2.CurrentVelocity.Y, 3);
+
+        // Same-motion rescale path also updates velocity.
+        seq2.SetCycle(Style, Motion, speedMod: 0.5f);
+        Assert.Equal(2f, seq2.CurrentVelocity.Y, 2);
+    }
+
     [Fact]
     public void SetCycle_SameMotionSameSpeed_StaysNoOp()
     {