fix(render #53): skip cache populate when classification is incomplete

User reported: the drudge statue on top of the Foundry (a multi-part
live-spawned entity with AnimPartChange + texChanges) renders only
PARTIALLY — some parts visible, some missing.

Root cause: the dispatcher's slow path skips a MeshRef when
_meshAdapter.TryGetRenderData returns null (mesh still async-decoding
via ObjectMeshManager.PrepareMeshDataAsync). The classified-batches
collector accumulates only the MeshRefs that DID resolve. At entity
boundary, the cache populates with the PARTIAL set. Frame-2 cache hits
serve that partial entry forever — even after the missing mesh loads,
the cache continues to skip those parts because classification never
reruns for cached entities.

Fix: track currentEntityIncomplete during the foreach. Set it true on
any null renderData. At entity boundary (and at end-of-loop), if the
flag is set, DROP the accumulated populate scratch instead of writing
it to the cache. The slow path retries on the next frame; once all
meshes have loaded, the populate fires correctly with the complete
classification.

Adds a regression test pinning the contract — incomplete entities
produce zero cache entries.

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

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

@@ -409,6 +409,20 @@ public sealed unsafe class WbDrawDispatcher : IDisposable
         // entity; subsequent tuples skip via this tracker.
         uint? lastHitEntityId = null;
 
+        // Tier 1 cache (#53) — incomplete-entity guard. When any MeshRef of
+        // the current entity has _meshAdapter.TryGetRenderData return null
+        // (mesh still async-decoding via ObjectMeshManager.PrepareMeshDataAsync),
+        // we mark the entity incomplete and DROP the accumulated populate
+        // scratch at entity boundary instead of writing it to the cache.
+        // Otherwise the cache would hold a partial classification (some parts
+        // missing), and frame-2 cache hits would persist that partial render
+        // even after the missing mesh loads — every subsequent frame sees the
+        // cache hit and skips re-classification, so the missing parts never
+        // recover. User-visible symptom: the drudge statue on top of the
+        // Foundry (multi-part Setup entity with AnimPartChange) renders with
+        // some parts missing permanently. Reset on entity change.
+        bool currentEntityIncomplete = false;
+
         foreach (var (entity, partIdx, landblockId) in _walkScratch)
         {
             if (diag) _entitiesSeen++;
@@ -433,6 +447,20 @@ public sealed unsafe class WbDrawDispatcher : IDisposable
                 lastHitEntityId = null;
             }
 
+            // Tier 1 cache (#53) — drop the previous entity's accumulated
+            // populate scratch BEFORE MaybeFlushOnEntityChange runs. If the
+            // previous entity ended incomplete (≥1 null renderData), we MUST
+            // NOT cache its partial classification: clear scratch and null
+            // the tracker so MaybeFlushOnEntityChange sees the cleaned state
+            // and no-ops for this entity. Reset the incomplete flag for the
+            // new entity so each one gets a fresh measurement.
+            if (populateEntityId.HasValue && populateEntityId.Value != entity.Id && currentEntityIncomplete)
+            {
+                _populateScratch.Clear();
+                populateEntityId = null;
+            }
+            currentEntityIncomplete = false;
+
             // Flush-on-entity-change: if the previous entity accumulated any
             // batches AND this iteration is for a different entity, populate
             // its cache entry now and reset the scratch buffer.
@@ -518,6 +546,14 @@ public sealed unsafe class WbDrawDispatcher : IDisposable
             var renderData = _meshAdapter.TryGetRenderData(gfxObjId);
             if (renderData is null)
             {
+                // Tier 1 cache (#53): mesh data is still async-decoding via
+                // WB's ObjectMeshManager.PrepareMeshDataAsync. Flag the entity
+                // as incomplete so the entity-boundary check (or end-of-loop
+                // check) drops the accumulated populate scratch instead of
+                // caching a partial classification. The slow path retries on
+                // the next frame; once all this entity's meshes have loaded,
+                // the populate fires with the complete batch set.
+                currentEntityIncomplete = true;
                 if (diag) _meshesMissing++;
                 continue;
             }
@@ -564,6 +600,17 @@ public sealed unsafe class WbDrawDispatcher : IDisposable
             if (diag && drewAny) _entitiesDrawn++;
         }
 
+        // Tier 1 cache (#53) — drop the accumulated populate scratch if the
+        // LAST entity in the loop ended incomplete (had ≥1 null renderData).
+        // Same reason as the entity-boundary handling above: avoid caching a
+        // partial classification. The slow path will retry on the next frame
+        // and populate correctly once all meshes have loaded.
+        if (currentEntityIncomplete)
+        {
+            _populateScratch.Clear();
+            populateEntityId = null;
+        }
+
         // Final flush: the last entity in _walkScratch has no "next iteration"
         // to trigger the entity-change flush, so commit its accumulated batches
         // here. No-op when the last entity was animated (populateEntityId stays