fix(motion): jump direction, AutoPos cadence, backward/strafe wire & anim

Closes a multi-bug knot in player motion outbound + remote inbound,
discovered via cdb live trace of retail (2026-05-01) and follow-up
visual verification.

Outbound (acdream → ACE):
- JumpAction velocity is BODY-LOCAL, not world (per retail
  CPhysicsObj::get_local_physics_velocity at 0x00512140 + ACE
  Player.HandleActionJump's set_local_velocity call). Was sending
  world; observers saw jump rotated by player yaw.
- Capture get_jump_v_z BEFORE LeaveGround() — the latter resets
  JumpExtent to 0, after which get_jump_v_z returned 0. Was sending
  Z=0 in every JumpAction.
- Backward/strafe-left jumps lost their horizontal velocity because
  LeaveGround → get_state_velocity returns zero for non-canonical
  motion (faithful to retail's FUN_00528960; retail papers over via
  adjust_motion translation, not yet ported). Compute the correct
  body-local launch velocity from input directly and push it back
  into the body so local prediction matches what we send.
- IsRunning HoldKey was gated on `input.Run && input.Forward`, so
  strafe-run and backward-run incorrectly broadcast as walk to
  observers — ACE then animated walk + dead-reckoned at walk speed
  while server position moved at run speed (visible as observer
  lag). Fixed: gate on any active directional axis.
- AutonomousPosition heartbeat 0.2s → 1.0s to match holtburger's
  AUTONOMOUS_POSITION_HEARTBEAT_INTERVAL and the ~1Hz observed in
  retail trace.
- Heartbeat now fires while in-world regardless of motion state
  (matches holtburger + retail's transient_state-based gate, not
  motion-based). Pre-fix the at-rest heartbeat was suppressed.

Inbound (ACE → acdream, remote retail player):
- Remote backward walk arrives as cmd=WalkForward + speed=-1.91
  (retail's adjust_motion'd form). Two bugs were stacking:
  1. AnimationSequencer fast-path returned without updating when
     sign(speedMod) flipped while motion stayed equal — kept playing
     forward at old positive framerate. Fixed: bypass fast-path on
     sign change so the full re-setup runs.
  2. GameWindow clamped negative speedMod to 1.0 when stuffing
     InterpretedState.ForwardSpeed, making get_state_velocity
     produce forward velocity. Fixed: pass speedMod through verbatim
     so the dead-reckoning body translates backward.

Issue #38 filed: 30Hz physics tick produces a chase-camera smoothness
regression at 60+ FPS render. Standard render-time interpolation is
the recommended fix (separate phase).

Findings + comparison vs retail/holtburger:
  docs/research/2026-05-01-retail-motion-trace/findings.md
  docs/research/2026-05-01-retail-motion-trace/fixes.md

TODO: port retail's adjust_motion (FUN_00528010) properly so
get_state_velocity works for all directions natively — would let us
drop the workaround in PlayerMovementController jump path and the
clamp in GameWindow.

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

src/AcDream.Core/Physics/AnimationSequencer.cs

@@ -389,11 +389,18 @@ public sealed class AnimationSequencer
         // This keeps the run/walk loop smooth when a new UpdateMotion arrives
         // with a different ForwardSpeed (e.g. when the server broadcasts a
         // player's updated RunRate mid-step).
+        //
+        // **Sign-flip case (2026-05-02):** when the server sends adjust_motion'd
+        // backward walk as `WalkForward + speed=-N`, motion stays 0x45000005
+        // but speedMod sign flips. We MUST do a full cycle restart in that case
+        // so the new (negative) framerate takes effect; otherwise the cycle
+        // keeps playing forward with the old positive framerate and the
+        // observer sees the player walking forward despite the negative speed.
         if (CurrentStyle == style && CurrentMotion == motion
-            && _firstCyclic != null && _queue.Count > 0)
+            && _firstCyclic != null && _queue.Count > 0
+            && MathF.Sign(speedMod) == MathF.Sign(CurrentSpeedMod))
         {
             if (MathF.Abs(speedMod - CurrentSpeedMod) > 1e-4f
-                && MathF.Sign(speedMod) == MathF.Sign(CurrentSpeedMod)
                 && MathF.Abs(CurrentSpeedMod) > 1e-6f)
             {
                 MultiplyCyclicFramerate(speedMod / CurrentSpeedMod);