feat(physics): live-entity collision plumbing (Commit A)

Plumbing-only foundation for the upcoming live-entity (NPC / monster
/ player) collision port. No behavior change — the new fields default
to zero/None so the 5 existing static-entity Register call sites in
GameWindow.cs are untouched.

Wire layer:
- CreateObject parser now surfaces PhysicsState (acclient.h:2815 —
  ETHEREAL_PS=0x4, IGNORE_COLLISIONS_PS=0x10, HAS_PHYSICS_BSP_PS=0x10000,
  ...) which the parser previously dropped at line ~337 with a bare
  `pos += 4`.
- CreateObject parser now surfaces ObjectDescriptionFlags (the retail
  PWD._bitfield trailer per acclient.h:6431-6463), where
  acclient_2013_pseudo_c.txt:406898-406918 ACCWeenieObject::IsPK /
  IsPKLite / IsImpenetrable read bits 5 / 25 / 21 directly. Previously
  read-and-discarded.
- WorldSession.EntitySpawn carries both new fields through to subscribers.

Physics layer:
- New `EntityCollisionFlags` enum (IsPlayer / IsCreature / IsPK /
  IsPKLite / IsImpenetrable) + `FromPwdBitfield` helper. Bit
  positions verified against retail's SetPlayerKillerStatus (
  acclient_2013_pseudo_c.txt:441868-441890) which maps
  PKStatusEnum→bitfield exactly: PK=0x4→bit5, PKLite=0x40→bit25,
  Free=0x20→bit21.
- `ShadowEntry` extended with `State` (raw PhysicsState bits) +
  `Flags` (decoded EntityCollisionFlags). Backward-compatible — all
  five existing landblock-entity Register call sites omit them.
- `ShadowObjectRegistry.UpdatePosition(entityId, pos, rot, ...)` —
  fast-path for the 5–10 Hz UpdatePosition (0xF748) stream the server
  emits per visible entity. Reuses the entry's existing shape +
  state + flags. Mirrors retail's CPhysicsObj::SetPosition
  (acclient_2013_pseudo_c.txt:284276) which keeps the same shape and
  re-registers cell membership.
- `ObjectInfoState` adds `IsPK = 0x800` and `IsPKLite = 0x1000`
  matching retail's OBJECTINFO::state bits (acclient.h:6190-6194).
  Used by Commit C's PvP exemption gate.

Tests:
- `EntityCollisionFlagsTests` — 7 tests covering empty / each bit
  alone / PK+player combo / unrelated-bit ignore.
- `ShadowObjectRegistryTests` — 5 new tests: UpdatePosition moves
  entry to new cell, preserves State/Flags, unregistered no-op,
  Register stores State/Flags, defaults are zero/None.
- `CreateObjectTests` — 3 new tests verifying PhysicsState + PWD
  bitfield (with PK / PKLite bit cases) parse and surface.

1454 → 1454 + 15 = covered by suite. dotnet build + dotnet test
green.

Foundation for Commit B (live-entity registration) and Commit C
(PvP exemption block in FindObjCollisions).

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

src/AcDream.Core/Physics/ShadowObjectRegistry.cs

@@ -19,11 +19,24 @@ public sealed class ShadowObjectRegistry
 
     /// <summary>
     /// Register an entity into the cells it overlaps based on world position + radius.
+    ///
+    /// <para>
+    /// The optional <paramref name="state"/> + <paramref name="flags"/>
+    /// parameters carry retail <c>PhysicsState</c> bits and decoded
+    /// <see cref="EntityCollisionFlags"/> respectively, so the
+    /// <c>FindObjCollisions</c> retail-faithful exemption block (PvP rule,
+    /// ETHEREAL skip, viewer-vs-creature) can short-circuit without an
+    /// extra lookup. Default <c>state=0</c> + <c>flags=None</c> preserves
+    /// the original "static decoration" behavior — the existing 5
+    /// landblock-entity registration sites pass nothing.
+    /// </para>
     /// </summary>
     public void Register(uint entityId, uint gfxObjId, Vector3 worldPos, Quaternion rotation,
                          float radius, float worldOffsetX, float worldOffsetY, uint landblockId,
                          ShadowCollisionType collisionType = ShadowCollisionType.BSP,
-                         float cylHeight = 0f, float scale = 1.0f)
+                         float cylHeight = 0f, float scale = 1.0f,
+                         uint state = 0u,
+                         EntityCollisionFlags flags = EntityCollisionFlags.None)
     {
         Deregister(entityId);
 
@@ -38,7 +51,8 @@ public sealed class ShadowObjectRegistry
         int minCy = Math.Max(0, (int)((localY - radius) / 24f));
         int maxCy = Math.Min(7, (int)((localY + radius) / 24f));
 
-        var entry = new ShadowEntry(entityId, gfxObjId, worldPos, rotation, radius, collisionType, cylHeight, scale);
+        var entry = new ShadowEntry(entityId, gfxObjId, worldPos, rotation, radius,
+                                    collisionType, cylHeight, scale, state, flags);
         var cellIds = new List<uint>();
 
         uint lbPrefix = landblockId & 0xFFFF0000u;
@@ -62,6 +76,56 @@ public sealed class ShadowObjectRegistry
         _entityToCells[entityId] = cellIds;
     }
 
+    /// <summary>
+    /// Update an already-registered entity's world position + rotation,
+    /// preserving its <see cref="ShadowEntry.State"/>,
+    /// <see cref="ShadowEntry.Flags"/>, and shape parameters.
+    ///
+    /// <para>
+    /// Cheaper than <see cref="Deregister"/> + <see cref="Register"/> for
+    /// the 5–10 Hz <c>UpdatePosition (0xF748)</c> stream the server emits
+    /// per visible entity: this is the path retail's
+    /// <c>CPhysicsObj::SetPosition</c> takes (cited at
+    /// <c>acclient_2013_pseudo_c.txt:284276</c>) — same shape, new cell
+    /// membership. If the entity isn't already registered, this is a
+    /// no-op so callers don't have to gate.
+    /// </para>
+    /// </summary>
+    public void UpdatePosition(uint entityId, Vector3 worldPos, Quaternion rotation,
+                               float worldOffsetX, float worldOffsetY, uint landblockId)
+    {
+        // Find the existing entry (any cell holds a copy with the same
+        // entity-scoped state + flags + shape).
+        if (!_entityToCells.TryGetValue(entityId, out var oldCells) || oldCells.Count == 0)
+            return;
+
+        ShadowEntry? template = null;
+        foreach (var oldCellId in oldCells)
+        {
+            if (_cells.TryGetValue(oldCellId, out var list))
+            {
+                foreach (var e in list)
+                {
+                    if (e.EntityId == entityId)
+                    {
+                        template = e;
+                        break;
+                    }
+                }
+            }
+            if (template is not null) break;
+        }
+        if (template is null)
+            return;
+
+        // Preserve everything except position + rotation.
+        var t = template.Value;
+        Register(entityId, t.GfxObjId, worldPos, rotation, t.Radius,
+                 worldOffsetX, worldOffsetY, landblockId,
+                 t.CollisionType, t.CylHeight, t.Scale,
+                 t.State, t.Flags);
+    }
+
     /// <summary>Remove an entity from all cells it was registered in.</summary>
     public void Deregister(uint entityId)
     {
@@ -203,4 +267,18 @@ public readonly record struct ShadowEntry(
     float Radius,
     ShadowCollisionType CollisionType = ShadowCollisionType.BSP,
     float CylHeight = 0f,
-    float Scale = 1.0f);
+    float Scale = 1.0f,
+    /// <summary>
+    /// Retail <c>PhysicsState</c> bits (<c>acclient.h:2815</c>). Used
+    /// by <c>FindObjCollisions</c> to honor <c>ETHEREAL_PS=0x4</c> +
+    /// <c>IGNORE_COLLISIONS_PS=0x10</c> short-circuits. Zero for static
+    /// landblock entities (default behavior matches pre-Commit-A).
+    /// </summary>
+    uint State = 0u,
+    /// <summary>
+    /// Decoded player / PK / PKLite / Impenetrable flags driving the
+    /// retail PvP exemption block in <c>FindObjCollisions</c>. Built
+    /// from <c>PWD._bitfield</c> at <c>CreateObject</c> time via
+    /// <see cref="EntityCollisionFlagsExt.FromPwdBitfield(uint)"/>.
+    /// </summary>
+    EntityCollisionFlags Flags = EntityCollisionFlags.None);