feat(physics): C4 route 4b-2 — remote far snap through the canonical placement

Flips the SetPositionSimple classification (contact, PlayerDistance >= 96 m) for
remotes onto 4b-1's drive controller and deletes both legacy far blocks, both
duplicated 96f/4f constant pairs, and both `?? Vector3.Zero` fabrications. The
4 m constant now exists exactly once. Teleport and cell-less stay legacy for
4b-3.

Retail: MoveOrTeleport @0x00516330's far branch runs StopInterpolating
@0x005163CB before SetPositionSimple @0x005163D9 and returns 1 @0x005163E8
regardless — the SetPositionError is discarded — so HandleReceivedPosition arms
ConstrainTo @0x00454272 post-move on commit AND on failure. The x87 parity
decode at @0x00516393-@0x0051639E puts exactly 96.0 on the far branch.
SetPositionSimple @0x005162B0 builds flags 0x1012 at @0x005162C4.

Non-commit outcomes still advance the body, because retail's SetPositionInternal
@0x00515BD0 commits the destination via store_position @0x00515CE2 when no cell
resolves. The partition is by STAGE, not heuristic, enforced by an exhaustive
switch: Refused/Contention/NotApplicable/RejectedPreparation store (the placement
never executed); Committed/Deferred/RejectedByPlacement do not (the engine ran
and refused, matching retail's non-storing returns @0x00515CB2 and @0x00515CD5).
Without this a refused far snap froze the remote with an emptied queue.

Also fixes a shipped defect this route made live: ParkDeferred's quiescence parks
withdrew the entity (InWorld=false, clock suspended, residency removed) and were
never restorable, while Forget(restoreCancelledPark: true) runs for every
accepted Position on every entity. The restorable decision now lives inside
ParkDeferred AFTER SnapToCell, reading body.CellPosition.ObjCellId — the value
RestoreParkWithdrawal actually restores at — against every live quiescence
rather than one minimum-OperationId token. The three pre-snap fields are hoisted
into locals because SnapToCell ends with InWorld = true. ParkCollisionResidents
passes restorableOnCancel: false explicitly; the plain unplaceable park is
provably unchanged. RestoreParkWithdrawal re-tests the prefix at restore time so
a retained route-2 park cannot re-admit into a prefix that began quiescing
during the park.

CanAttemptDestination is retained as an OPTIMISATION only, with the two Core
predicates it cannot reproduce written down at the pre-flight, plus the two
properties that depend on it staying there.

Four fix rounds and eight Opus reviews. The slice was fully green at 10,990,
10,997 and 11,004 while containing real defects — a frozen remote pinned as
correct by its own test, a fallback that over-wrote on the exact retail paths
that decline to store, and a park guard incomplete on two independent axes.

Register: AP-137 (leftover classifications take AP-87's catch-up; states the
cell-less enqueue-vs-place delta deferred to 4b-3, that RejectedData is applied
anyway, and the headless divergence), AP-138 (the refusable far placement),
AP-136 narrowed to match the relocation. #309's acceptance steps rewritten —
step 5 previously asserted a recovery the code does not perform — and gated on a
new ACDREAM_PROBE_PARK=1 signal so the check cannot pass while broken.

Suite 11,009 passed / 4 skipped / 0 failed against a measured 10,968 baseline.
The 10,973 figure recorded earlier was wrong and is corrected here.

Connected gate outstanding: the two-client far-snap walk and #309.

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

src/AcDream.Runtime/Physics/RuntimeRemoteSteadyStatePosition.cs

@@ -16,16 +16,15 @@ namespace AcDream.Runtime.Physics;
 /// incarnations — retail's disassembly makes no <c>this==player</c>
 /// distinction on this path (see <c>ConstraintDistance</c>) — so one Runtime
 /// owner decides and applies both, replacing the two independent per-kind
-/// copies that used to live in <c>LiveEntityNetworkUpdateController</c>. The
-/// far (&gt;=96 m) and teleport/cell-less branches remain the legacy App path
-/// until C4 route 4b.
+/// copies that used to live in <c>LiveEntityNetworkUpdateController</c>.
 ///
 /// <para>
 /// <b>Exactly two dispositions are owned here.</b> Everything else —
 /// <c>SetPositionSimple</c>, <c>SetPosition</c>, <c>RejectedAuthority</c>,
 /// <c>RejectedData</c>, and "not classified at all" (<see langword="null"/>) —
-/// falls through to the untouched legacy App routing. "Not Interpolate" must
-/// never be read as "far".
+/// belongs to <see cref="RuntimeRemoteFarSnapPosition"/>, which owns the far
+/// (&gt;=96 m) snap from C4 route 4b-2 and states the policy for the
+/// leftovers. "Not Interpolate" must never be read as "far".
 /// </para>
 /// </summary>
 internal static class RuntimeRemoteSteadyStatePosition
@@ -157,9 +156,23 @@ internal static class RuntimeRemoteSteadyStatePosition
     /// does NOT run on the airborne no-op.
     ///
     /// <para>
-    /// Route-gated so it can only fire for a classification route 4a owns:
-    /// every other classification still arms the leash through the legacy
-    /// pre-operation call site, unchanged, until 4b moves them too.
+    /// Route-gated by
+    /// <see cref="RuntimeRemoteFarSnapPosition.OwnsAfterOperationConstraint"/>
+    /// — route 4a's two dispositions plus (C4 route 4b-2) the far snap. Every
+    /// other classification still arms the leash through the legacy
+    /// pre-operation call site, unchanged, until 4b-3 moves them too. The
+    /// legacy site reads the SAME predicate, so no classification can be
+    /// armed twice or left unarmed.
+    /// </para>
+    ///
+    /// <para>
+    /// This deliberately does not consult the outcome of the operation it
+    /// follows. Retail's far branch returns 1 @0x005163E8 unconditionally —
+    /// <c>MoveOrTeleport</c> discards <c>SetPositionSimple</c>'s
+    /// <c>enum SetPositionError</c> return entirely — so
+    /// <c>HandleReceivedPosition</c> arms the leash even when the placement
+    /// FAILED. "Arm only on commit" is the natural misreading and is the same
+    /// shape as the already-recorded unarmed-leash bug.
     /// </para>
     /// </summary>
     internal static bool TryArmConstraintAfterOperation(
@@ -168,7 +181,8 @@ internal static class RuntimeRemoteSteadyStatePosition
     {
         ArgumentNullException.ThrowIfNull(remote);
         if (route is not { } selected
-            || !OwnsSteadyState(selected)
+            || !RuntimeRemoteFarSnapPosition.OwnsAfterOperationConstraint(
+                selected)
             || !selected.ConstrainAfterRouting
             || remote.Host is not { } host)
         {