fix(anim): Phase L.1c chase arrival + stale destination

User-observed regressions on commit 186a584:

1. "Monster keeps running in different directions when it should be
   attacking" — chase oscillates around the player at melee range
   instead of stopping. Root cause: arrival check used MinDistance
   only (retail's algorithm), but ACE puts the melee threshold in
   DistanceToObject (default 0.6) and leaves MinDistance at 0. So
   our check was never satisfied; body kept re-targeting around the
   player as each MoveTo refresh moved the destination.

   Fix: arrival = dist <= max(MinDistance, DistanceToObject) + epsilon.
   Honors retail when retail sets MinDistance > 0; falls through to
   ACE's DistanceToObject when MinDistance is 0. Confirmed by
   independent research (named retail decomp, ACE wire writers,
   holtburger client) that DistanceToObject is the documented chase
   threshold in ACE; retail's MinDistance is only meaningful when
   server config overrides the default 0.

2. "Monster disappears, then runs in place" — entity left our
   streaming view, server stopped emitting MoveTo, last destination
   stayed cached. When entity re-entered view, body still steered
   toward the stale point, eventually arrived (V=0), animation kept
   playing → "running on the spot."

   Fix: 1.5 s stale-destination timeout. ACE re-emits MoveTo at
   ~1 Hz during active chase; if no fresh packet for 1.5 s, the
   entity has either left view, transitioned off MoveTo without us
   seeing the cancel UM, or had its move cancelled server-side.
   Clear destination + zero velocity so the next interpreted-motion
   UM (or fresh MoveTo) drives the body cleanly.

Also confirmed (via dispatched research subagent against ACE writer
side, named retail MovementManager::PerformMovement, and holtburger):
the wire's "Origin" field IS the destination, not the start position.
My driver's interpretation was correct; the symptoms were arrival
threshold + staleness, not a misread of the wire.

Tests: 1412 → 1414 (ACE-melee arrival, retail-MinDistance arrival).

Origin-stale lag during active chase remains — server's Origin is
the target's position at packet-emit time, ~1 s behind the player.
For type 6 MoveToObject, the retail-faithful fix is target-guid
live resolution per HandleUpdateTarget @ 0x0052a7d0; deferred per
the pseudocode doc's "out of scope" list. For type 7 there's no
fix without target-velocity prediction.

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

src/AcDream.Core/Physics/RemoteMoveToDriver.cs

@@ -84,6 +84,21 @@ public static class RemoteMoveToDriver
     /// </summary>
     public const float ArrivalEpsilon = 0.05f;
 
+    /// <summary>
+    /// Maximum staleness (seconds) of the most recent MoveTo packet
+    /// before the driver gives up steering. ACE re-emits MoveTo at ~1 Hz
+    /// during active chase; if no fresh packet arrives for this long,
+    /// the entity has likely either left our streaming view, switched
+    /// to a non-MoveTo motion the server's broadcast didn't reach us
+    /// for, or had its move cancelled server-side without our seeing
+    /// the cancel UM. In any of those cases, continuing to drive the
+    /// body toward a stale destination produces the "monster runs in
+    /// place after popping back into view" symptom (2026-04-28).
+    /// 1.5 s gives us comfortable margin over the ~1 s emit cadence
+    /// while still failing fast on real loss-of-state.
+    /// </summary>
+    public const double StaleDestinationSeconds = 1.5;
+
     public enum DriveResult
     {
         /// <summary>Within arrival window — caller should zero velocity.</summary>
@@ -95,17 +110,33 @@ public static class RemoteMoveToDriver
 
     /// <summary>
     /// Steer body orientation toward <paramref name="destinationWorld"/>
-    /// and report whether the body has arrived (within
-    /// <paramref name="minDistance"/>) or should keep running. Pure
-    /// function — emits the updated orientation via
+    /// and report whether the body has arrived or should keep running.
+    /// Pure function — emits the updated orientation via
     /// <paramref name="newOrientation"/> (the input is not mutated; the
     /// caller assigns the new value back to its body).
     /// </summary>
+    /// <param name="minDistance">
+    /// <c>min_distance</c> from the wire's MovementParameters block —
+    /// retail's <c>HandleMoveToPosition</c> chase-arrival threshold.
+    /// </param>
+    /// <param name="distanceToObject">
+    /// <c>distance_to_object</c> from the wire — ACE's chase-arrival
+    /// threshold (default 0.6 m, the melee range). The actual arrival
+    /// gate is <c>max(minDistance, distanceToObject)</c>: retail-faithful
+    /// when retail sends <c>min_distance</c> &gt; 0, ACE-compatible when
+    /// ACE puts the value in <c>distance_to_object</c> with
+    /// <c>min_distance == 0</c>. Without this, ACE's <c>min_distance==0</c>
+    /// chase packets never arrive — the body keeps re-targeting around
+    /// the player at melee range and visibly oscillates between facings,
+    /// which is the user-reported "monster keeps running in different
+    /// directions when it should be attacking" symptom (2026-04-28).
+    /// </param>
     public static DriveResult Drive(
         Vector3 bodyPosition,
         Quaternion bodyOrientation,
         Vector3 destinationWorld,
         float minDistance,
+        float distanceToObject,
         float dt,
         bool moveTowards,
         out Quaternion newOrientation)
@@ -116,10 +147,15 @@ public static class RemoteMoveToDriver
         float dy = destinationWorld.Y - bodyPosition.Y;
         float dist = MathF.Sqrt(dx * dx + dy * dy);
 
-        // Arrival predicate per retail MoveToManager::HandleMoveToPosition
-        // (chase: dist ≤ min_distance; flee branch is unused here, but
-        // we honor the moveTowards flag for symmetry).
-        if (moveTowards && dist <= minDistance + ArrivalEpsilon)
+        // Arrival predicate. Retail (named decomp): dist ≤ min_distance.
+        // ACE port: dist ≤ DistanceToObject. ACE's wire put the melee
+        // threshold in DistanceToObject (default 0.6) and left
+        // MinDistance=0; retail server config presumably set MinDistance.
+        // Defensive port: take the larger so we honor whichever field is
+        // populated. Flee branch is unused here but we honor the
+        // moveTowards flag for symmetry.
+        float arrivalThreshold = MathF.Max(minDistance, distanceToObject);
+        if (moveTowards && dist <= arrivalThreshold + ArrivalEpsilon)
         {
             newOrientation = bodyOrientation;
             return DriveResult.Arrived;