phase(N.4) Tasks 22+23 fixup: trigger WB mesh loads + correct SurfaceId source

Task 26 visual verification surfaced three bugs in the dispatcher.
Two are fixed here; the third is documented as a remaining issue.

1. WB's IncrementRefCount only bumps a usage counter — it does NOT
   trigger mesh loading. Fixed in WbMeshAdapter.IncrementRefCount:
   call PrepareMeshDataAsync(id, isSetup: false) on first registration.
   Result auto-enqueues to _stagedMeshData (line 510 of WB's
   ObjectMeshManager) which Tick() drains onto the GPU.

2. EntitySpawnAdapter never registered per-instance entity meshes
   with WB. LandblockSpawnAdapter only registers atlas-tier
   (ServerGuid == 0); per-instance entities fell through. Fixed by
   adding optional IWbMeshAdapter constructor param + tracking unique
   GfxObj ids per server-guid for IncrementRefCount on OnCreate /
   DecrementRefCount on OnRemove.

3. WbDrawDispatcher.ResolveTexture used batch.SurfaceId which WB
   never populates (line 1746 of ObjectMeshManager only sets
   batch.Key — the TextureKey struct that has SurfaceId). Switched
   to batch.Key.SurfaceId.

Plus diagnostic counters (ACDREAM_WB_DIAG=1) for entity-seen / drawn
/ mesh-missing / draws-issued counts.

Status: with these fixes the dispatcher now issues real draw calls
(~16K/frame, validated via diagnostic). However visual verification
shows characters appear "exploded" (parts spaced too far apart) and
scenery (trees/rocks/fences/buildings) does not appear. Root cause
analysis pending — Adjustment 7 in the plan documents the deferred
work. Flag stays default-off; legacy renderer remains the
production path.

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

src/AcDream.App/Rendering/Wb/EntitySpawnAdapter.cs

@@ -49,11 +49,18 @@ public sealed class EntitySpawnAdapter
 {
     private readonly ITextureCachePerInstance _textureCache;
     private readonly Func<WorldEntity, AnimationSequencer> _sequencerFactory;
+    private readonly IWbMeshAdapter? _meshAdapter;
 
     // Per-server-guid state. Written on OnCreate, released on OnRemove.
     // Single-threaded: called only from the render thread (same as GpuWorldState).
     private readonly Dictionary<uint, AnimatedEntityState> _stateByGuid = new();
 
+    // Per-server-guid set of GfxObj ids registered with the mesh adapter,
+    // so OnRemove can decrement each. Per-instance entities don't go through
+    // LandblockSpawnAdapter, so without this their meshes would never load
+    // (WB doesn't know they exist).
+    private readonly Dictionary<uint, HashSet<ulong>> _meshIdsByGuid = new();
+
     /// <param name="textureCache">
     /// Per-instance texture decode path. In production this is the
     /// <see cref="TextureCache"/> instance (which implements
@@ -66,14 +73,23 @@ public sealed class EntitySpawnAdapter
     /// and server-supplied motion table override. Tests pass a lambda that
     /// returns a stub sequencer.
     /// </param>
+    /// <param name="meshAdapter">
+    /// Optional WB mesh adapter. When non-null, <see cref="OnCreate"/>
+    /// registers each unique <c>MeshRef.GfxObjId</c> with the adapter so WB
+    /// background-loads the mesh data; <see cref="OnRemove"/> decrements the
+    /// matching ref counts. When null, the adapter only tracks per-instance
+    /// state without driving WB lifecycle (test mode + flag-off mode).
+    /// </param>
     public EntitySpawnAdapter(
         ITextureCachePerInstance textureCache,
-        Func<WorldEntity, AnimationSequencer> sequencerFactory)
+        Func<WorldEntity, AnimationSequencer> sequencerFactory,
+        IWbMeshAdapter? meshAdapter = null)
     {
         ArgumentNullException.ThrowIfNull(textureCache);
         ArgumentNullException.ThrowIfNull(sequencerFactory);
         _textureCache = textureCache;
         _sequencerFactory = sequencerFactory;
+        _meshAdapter = meshAdapter;
     }
 
     /// <summary>
@@ -126,6 +142,23 @@ public sealed class EntitySpawnAdapter
             state.SetPartOverride(po.PartIndex, po.GfxObjId);
 
         _stateByGuid[entity.ServerGuid] = state;
+
+        // Register each unique GfxObj id with WB so the meshes background-load.
+        // Includes both the entity's natural MeshRefs AND any server-sent
+        // PartOverride GfxObjs (weapons, clothing, helmets) — those replace the
+        // Setup default and need their own mesh data uploaded.
+        if (_meshAdapter is not null)
+        {
+            var unique = new HashSet<ulong>();
+            foreach (var meshRef in entity.MeshRefs)
+                unique.Add((ulong)meshRef.GfxObjId);
+            foreach (var po in entity.PartOverrides)
+                unique.Add((ulong)po.GfxObjId);
+
+            _meshIdsByGuid[entity.ServerGuid] = unique;
+            foreach (var id in unique) _meshAdapter.IncrementRefCount(id);
+        }
+
         return state;
     }
 
@@ -134,7 +167,16 @@ public sealed class EntitySpawnAdapter
     /// on <c>RemoveObject</c>. Unknown guids (never spawned, or already
     /// removed) are silently ignored.
     /// </summary>
-    public void OnRemove(uint serverGuid) => _stateByGuid.Remove(serverGuid);
+    public void OnRemove(uint serverGuid)
+    {
+        _stateByGuid.Remove(serverGuid);
+
+        if (_meshAdapter is not null && _meshIdsByGuid.TryGetValue(serverGuid, out var ids))
+        {
+            foreach (var id in ids) _meshAdapter.DecrementRefCount(id);
+            _meshIdsByGuid.Remove(serverGuid);
+        }
+    }
 
     /// <summary>
     /// Look up the <see cref="AnimatedEntityState"/> for a server guid.