feat(physics): C4 route 4b-3 — remote teleport + cell-less through the canonical placement

Flips the last remote classification (SetPosition: teleport-advanced and
cell-less) onto 4b-1's RuntimeRemotePlacementDriveController, runs retail's
teleport_hook before the placement, and deletes the legacy remote-teleport
machinery. Contract: docs/research/2026-08-04-c4-route-4b-3-contract.md.

Retail: MoveOrTeleport @0x00516330's branch @0x00516386 -> teleport_hook
@0x005163EF -> SetFlags(0x1012) @0x00516414 -> SetPosition @0x00516420 ->
return 1 @0x00516438. The hook @0x00514ED0 runs BEFORE the placement and
regardless of its outcome. Retail places this branch unconditionally, at any
distance and any contact state (arg4 is read only @0x0051638E, after the
branch) — which is what retires AP-137's cell-less enqueue-vs-place delta.

D1 — the classifier's cell-less input is now the PRE-merge committed cell.
Retail's predicate is `this_1->cell == 0`, the BODY's own cell at
MoveOrTeleport entry (this_1 is assigned from this @0x00516334). acdream fed
the POST-merge canonical.FullCellId, which RefreshSnapshot ->
RefreshDerivedState -> SetFullCell has already stamped with the accepted wire
cell; a zero wire cell fails validation into RejectedData first. The shipped
remote cell-less predicate was therefore dead code, not merely different from
remotePlacementRequired. Threaded via a builder overload; route 1's overload
is untouched. The graphical !IsSpatiallyVisible arm of
projectionRequiresTeleportHook is deleted — a presentation predicate with no
retail analogue that fired the teleport machinery on a routine hot path.

Deleted: RemoteTeleportController (605), RemoteTeleportPlacement (85),
RemoteShadowPlacementSynchronizer (49), their 1,709 lines of tests, the
remotePlacementRequired predicate, the TeleportHookRequired plumbing, the
legacy pre-operation ConstrainTo fallback, and the player arm's legacy
!IsGrounded fallback. Net -2,030 lines.

Structural fix (two independent Opus reviews, round 1 FAIL/FAIL): three of the
four MAJORs were one defect — OnPosition carried two parallel inline copies of
the routing tail (player-guid, NPC-guid) that had drifted. Extracted
RunRemoteArmTail (3 call sites) and ApplyWireAirborneLeftoverBookkeeping (2),
both branches now share one implementation.

  A1  ToConstraintArm mapped AirborneSnap -> AirborneNoOperation, so the NPC
      arm armed ConstrainTo ZERO times for an out-of-contact wire-grounded
      creature — a regression this slice introduced while closing a
      structurally identical hole. Now maps to NearInterpolate; switch made
      total with a throwing default proven unreachable.
  R1  D2's write-nothing shape existed on the player arm only; NPC packets
      fell through and wrote the body. Retail makes no player/NPC distinction.
  R2  report_collision_end(this,1) @0x00514F31 was bound to
      ShadowObjects.Suspend, a port of a DIFFERENT retail function
      (remove_shadows_from_cells) that teleport_hook never calls. Now routes
      to RuntimeCollisionReportingState.LeaveWorld, which wraps the private
      ForceEnd in an admission-blocking transaction so a DoCollisionEnd
      callback cannot recreate the contact table.
  R3/A2 A teleported NPC synthesized ServerVelocity from the teleport distance
      (~1,000+ m/s) and planned a run cycle from it. Both the install and
      RemoteServerControlledVelocityCycle.Apply now gate on !isTeleportRoute.

BISECT HAZARD — A1's fix is correct only BECAUSE R1 landed. AirborneSnap is
reachable wire-airborne on the NPC arm only while D2's shape is missing there.
Reverting R1 alone silently inverts A1 into the opposite divergence: arming
where retail returns 0. Revert both or neither.

Also in the velocity hunk: the NPC block's two !IsPlayerGuid(update.Guid)
guards were dropped when it was wrapped in `if (!isTeleportRoute)`. Safe — all
five exit paths of the enclosing IsPlayerGuid block return, so the predicate is
unconditionally false below it — but it was unremarked by both reviews.

Register: AP-137 REWRITTEN (not deleted) to the surviving acdream-only
divergences — null classification during the login window and Rejected*
through UnroutedCatchUp keep a row. AD-42's RemoteTeleportController citation
retired; AP-136/AP-138 writer lists corrected to the two surviving non-Position
rebucket writers; AP-138 gains the teleport arm as a second producer of the
visible-without-collision residual (retirement path remains #309). AP-135 is
untouched and its two airborne bookkeeping writes are preserved on both arms.
AP-131 does not retire; #276 does not close.

Proof obligation 1: ParkCollisionResidents' overlap throw stays unreachable —
the teleport arm adds packets to the same TryBeginExclusiveAuthoredPlacement
one-operation-per-key machinery the far arm uses, opens no new operation shape,
and every DeferredCell outcome cancels synchronously with
restoreCancelledPark: true. The guarded property remains
HasOldPrefixPlacementDebt's stall, not a throw (4b-1's B2 caveat stands).

Correction to an earlier claim: LiveEntityPresentationController's
_activePlacementOwners was NOT write-never at HEAD —
remotePlacementRequired -> BeginPlacement -> Begin -> BeginAuthoritativePlacement
was a live writer chain. It becomes write-never BECAUSE this slice deletes that
chain, which is why deleting the dead half is behaviour-preserving.

Probe: ACDREAM_PROBE_REMOTE_TELEPORT=1 emits one [remote-teleport] line per
routed arm (guid, cause, hook-ran, placement status). TEMPORARY, strip with the
probe family.

Carried, disclosed not fixed: no dedicated bidirectional collision-partner test
for R2 (the wiring, not LeaveWorld itself, is what lacks coverage); the
stress test's teleport step drives hand-written field assignments rather than
the canonical arm; the per-packet runTeleportHook closure allocation (network
path, not the resolve path Slice I's 0 B discipline governs — file before
route 5 adds a fourth call site). B2: IRuntimeCollisionReportObserver has zero
production implementations, so retail's bidirectional DoCollisionEnd half still
reaches no gameplay consumer — this fix closes the wrong-function binding, not
that nobody listens.

Complete Release suite MEASURED at 11,013 passed / 4 skipped / 0 failed
(baseline 11,027/4/0; net -14 = ~33 deleted test cases against ~19 added).
Neither known flake fired (#302 PortalProjectionTests GC-allocation, #308
NakEmissionTests wall-clock).

STILL OWED: the two-client connected gate, which MUST use an NPC/creature
teleport target. Both round-1 MAJORs lived on the NPC arm and the velocity
cycle early-returns for 0x50xxxxxx guids, so a player target structurally
cannot observe A1, A2, or R3.

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

docs/architecture/acdream-architecture.md

@@ -311,9 +311,7 @@ src/
       RemotePhysicsUpdater.cs -> ordinary/Hidden remote narrow-tick integration
       LiveEntityOrdinaryPhysicsUpdater.cs -> manager-less body Transition commits
       RemoteInboundMotionDispatcher.cs -> animation-optional retail UM funnel
-      RemoteTeleportController.cs -> incarnation-scoped loaded/pending placement owner
-      RemoteTeleportHook.cs   -> ordered retail teleport teardown seam
-      RemoteTeleportPlacement.cs -> collision-seated SetPosition transition commit
+      RemoteTeleportHook.cs   -> ordered retail teleport teardown seam (teleport_hook port; C4 route 4b-3 runs it from LiveEntityNetworkUpdateController's teleport arm dispatch, through RuntimeRemotePlacementDriveController)
     World/
       LiveEntityRuntime.cs    -> exact-key App projection/lifecycle host
       LiveEntityProjectionStore.cs -> materialized sidecars by RuntimeEntityKey
@@ -466,30 +464,26 @@ What exists and is active:
   and every routed hook. A delete/local-ID reuse during capture or during an
   earlier hook can never advance the displaced sequencer or send the old
   owner's remaining sound, particle, or light hooks to its replacement.
-- `RemoteTeleportController` owns the placement half of a fresh remote
-  teleport after `RemoteTeleportHook` has torn down movement/target state. It
-  collision-seats loaded destinations through `RemoteTeleportPlacement`; an
-  unloaded destination retains one generation- and PositionSequence-scoped
-  pending placement and resolves the latest accepted frame when that same
-  projection becomes visible. It neither owns GUID identity nor reconstructs
-  an entity. A placement failure after hydration restores the captured source
-  frame/cell/contact rather than leaving a visible collisionless projection;
-  source-resident shadows restore immediately, while an unloaded source
-  delegates one incarnation-scoped restore to
-  `LiveEntityPresentationController`, shared with Hidden/UnHide. A newer
-  placement transfers that marker into an explicit active-placement generation
-  before rebucketing even while Hidden. That generation suppresses every
-  intervening Hidden/UnHide and projection restore until the controller reaches
-  a stable result, then it either restores after collision seating, re-defers
-  its rollback source, or hands a Hidden result back for UnHide. The typed
-  `ILiveEntityRemotePlacementRuntime` seam permits a same-incarnation wrapper
-  rebind only around the canonical body; pending placement adopts that wrapper
-  before hydration and cannot silently lose ownership. Clearing a motion or
-  projectile component retains the incarnation's body/contract identity until
-  logical teardown. The production wrapper exposes an immutable body, while
-  hydration defensively validates arbitrary implementations against the record
-  and rolls the retained body back on mismatch. Runtime binding snapshots the
-  interface Body getter once for validation, assignment, and state mutation.
+- **C4 route 4b-3 (2026-08-04) deleted `RemoteTeleportController` /
+  `RemoteTeleportPlacement` / `RemoteShadowPlacementSynchronizer` outright** —
+  605 + 85 + 49 lines of App-layer incarnation-scoped placement machinery,
+  replaced by routing the remote teleport/cell-less classification through
+  the SAME canonical `RuntimeRemotePlacementDriveController` the far snap
+  (C4 route 4b-2) already uses (`ApplyAcceptedRemoteTeleport`, sharing
+  `StoresAcceptedDestination`/`StoreAcceptedDestinationPose`). `teleport_hook`
+  (@0x00514ED0) still runs first, via `RemoteTeleportHook` invoked from
+  `LiveEntityNetworkUpdateController`'s teleport-arm dispatch (both the
+  player-guid and NPC-guid branches share one `RunRemoteArmTail` helper for
+  the routing-decision/currency/constraint-arm sequence — see the C4 4b-3
+  fix round, 2026-08-04, for why the two branches were unified there after
+  independently drifting). There is no separate "loaded vs pending
+  destination" placement path anymore: an unresolved destination collision
+  generation retains a preparation-stage retry inside the SAME drive
+  controller that far snap already retries through, not a second incarnation-
+  scoped machine, and `_activePlacementOwners`'s Hidden/UnHide visibility-edge
+  protection is gone with its only writer chain — the synchronous, single-
+  frame teleport commit removes the multi-frame window that protection
+  existed for.
   `GpuWorldState`
   rebuckets atomically and commits spatial visibility before draining its
   transition FIFO; `LiveEntityRuntime` rejects delayed duplicate edges. A

docs/architecture/code-structure.md

@@ -262,9 +262,7 @@ src/AcDream.App/
 │   ├── DeferredLiveEntityMotionRuntimeBindings.cs # fail-fast construction-order bridge
 │   ├── LiveEntityShadowPublisher.cs     # authoritative exact-owner/residency collision gate
 │   ├── RemoteInboundMotionDispatcher.cs # shared animated/headless UpdateMotion funnel
-│   ├── RemoteTeleportController.cs      # loaded/pending teleport placement ownership
-│   ├── RemoteTeleportHook.cs            # ordered retail teleport teardown actions
-│   └── RemoteTeleportPlacement.cs       # collision-seated SetPosition transition commit
+│   └── RemoteTeleportHook.cs            # ordered retail teleport teardown actions (teleport_hook port; C4 4b-3 deleted RemoteTeleportController/RemoteTeleportPlacement/RemoteShadowPlacementSynchronizer — the teleport arm now routes through RuntimeRemotePlacementDriveController, the same canonical placement owner the far snap uses)
 ├── World/
 │   ├── InboundPhysicsStateController.cs # timestamps + accepted spawn snapshots
 │   ├── LiveEntityRuntime.cs             # shipped: logical lifetime + ServerGuid↔entity.Id translation
@@ -417,28 +415,19 @@ radar/status targeting, effects, and audio remain closed until reveal. This
 distinction is part of the Slice E connected gate, not an alternate live-entity
 lifetime.
 
-Remote teleport placement is bounded in `Physics/RemoteTeleportController`,
-not `GameWindow`: it retains at most one pending request per materialized
-incarnation, scopes it by the live generation and accepted PositionSequence,
-and asks `RemoteTeleportPlacement` to collision-seat the current body when the
-destination projection is available. `GameWindow` supplies lifecycle and
-shadow-sync callbacks only; canonical identity remains in
-`RuntimeEntityDirectory`, and App placement retains the exact projection key.
-Failed hydration restores the captured source and delegates an
-incarnation-scoped shadow restore to `LiveEntityPresentationController` while
-that source is unloaded, so Hidden/UnHide and teleport never become competing
-restore owners. A newer placement transfers that restore into an explicit
-generation-scoped active-placement state before its rebucket visibility edge
-even while Hidden. All intervening Hidden/UnHide and projection edges defer to
-that owner until stable success or rollback completes; only then can it restore,
-re-defer the source, or hand a Hidden result back for UnHide. The
-`ILiveEntityRemotePlacementRuntime` seam keeps the complete cell/contact
-handoff available across same-body runtime-wrapper replacement; replacing the
-canonical body or dropping the placement contract within one incarnation is
-rejected even after an operational component clear. `RemoteMotion.Body` is
-constructor-owned; hydration compares pending/current wrappers directly to the
-record body rather than trusting wrapper-to-wrapper equality. Binding reads an
-interface Body getter once and reuses that snapshot. `GpuWorldState`
+**C4 route 4b-3 (2026-08-04) deleted `Physics/RemoteTeleportController` and
+`RemoteTeleportPlacement` outright** (605 + 85 lines, plus
+`RemoteShadowPlacementSynchronizer`, 49 lines). Remote teleport placement is
+no longer a separate App-layer incarnation-scoped machine — it is the SAME
+canonical `RuntimeRemotePlacementDriveController` route 4b-2's far snap
+already uses, dispatched via `ApplyAcceptedRemoteTeleport`, which shares
+`StoresAcceptedDestination`/`StoreAcceptedDestinationPose` unchanged.
+`teleport_hook` (@0x00514ED0) still runs first — `RemoteTeleportHook`,
+invoked from `LiveEntityNetworkUpdateController`'s teleport-arm dispatch —
+and its `report_collision_end(this, 1)` action now routes through
+`RuntimeCollisionReportingState.LeaveWorld` (the existing, exact port of
+that retail call) rather than `ShadowObjectRegistry.Suspend`, which ports a
+DIFFERENT retail function `teleport_hook` never calls. `GpuWorldState`
 performs remove+place as one spatial rebucket,
 then commits and serially drains visibility edges; `LiveEntityRuntime` filters
 delayed duplicates. A rollback inside an observer cannot race the outer