wgpu streaming: multi-pool growth, frustum-only residency, sorted convergence

Five interlocking fixes that take --streaming on the big federation
scene from "5 fps + endless flicker + infinite cold-load" to a
stable 35-49 fps with a converged working set.

1. Multi-sub-buffer WgpuBufferPool. Pool now grows lazily by adding
   sub-buffers of per_sub_buffer_capacity_ when alloc demand exceeds
   existing free runs. Each Slice carries (buffer, offset, size,
   sub_idx). On driver refusal of addSubBuffer, growth_disabled_
   latches so subsequent allocs don't keep retrying and log-spamming.
   pool_can_fit consults can_grow() to know when growth could rescue
   a candidate vs when eviction is the only path.

2. Split cull / stream benchmark timers. The previous "cull[wall]"
   metric was actually cull + driveStreamingLoads, blaming the wrong
   subsystem (~170 ms of "cull" was synchronous disk I/O).

3. frustum_visible_count on Chunk, populated in cullModelCpuCompute
   right after the per-instance aabbInFrustum check. driveStreamingLoads
   now keys residency on this instead of total_visible_draws (which
   includes contribution + HiZ). HiZ visibility flips frame-to-frame
   as occluders shift; using it for residency caused chunks to be
   evicted then immediately re-loaded, every frame, even with a
   stationary camera — both the perf cliff and the visible flicker.

4. Distance-sorted candidates in driveStreamingLoads. Walk the
   non-resident frustum-visible chunks in distance order (closest
   first). With sorted processing, evict_farthest_than converges
   monotonically: each swap replaces a far resident with a closer
   candidate; once the next candidate is farther than every
   remaining resident, the loop exits. Without sorting the loader
   visited candidates in model/chunk-id order, swapping random
   chunks every frame without ever converging.

5. 10% eviction hysteresis (EVICT_DIST2_RATIO = 1.21). On scenes
   where many chunks are clustered at similar distance from the
   camera (e.g. several chunks all ~370 m away), naive
   "evict any resident strictly farther than candidate" triggers
   sub-meter swaps every frame, never resting. Requiring the victim
   to be 10% farther in linear distance kills these cycles while
   still allowing genuine "much closer" candidates to evict.

Plus: latched bench_warm_done_ on the cold-load gate, with a
5-frames-of-zero-loads convergence test (default-camera big scene
converges in 20 frames) and a 600-frame timeout fallback that prints
exactly once.

Measured on the test federation (111 sidecars, ~3 GB raw, 1 M
instances) with the user's close-in camera:
- avg 35 fps (was 5), median 49 fps (was 7)
- cull 19 ms (now the bottleneck), stream 5-8 ms (was 172)
- p99 184 ms — occasional big-chunk load on the render thread;
  background-thread I/O would smooth that out as a follow-up.

With the default wide camera:
- avg 40 fps, converges in 20 frames, residency grows naturally
  from 59 → 76 chunks as orbit shifts the frustum.

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

src/ifcviewer-wgpu/WgpuViewportWindow.h

@@ -422,6 +422,21 @@ public:
     // the old hand-picked streaming_vram_budget_bytes_ knob entirely.
     WgpuBufferPool pool_;
 
+    // Per-frame streaming activity, written by driveStreamingLoads,
+    // consumed by the benchmark harness to delay the orbit sweep until
+    // the initial cold-load settles. `loads` = chunks brought resident
+    // this frame; `more_pending` = the loader wants to keep going.
+    int  streaming_loads_this_frame_ = 0;
+    bool streaming_more_pending_     = false;
+
+    // Bench warm-phase counters. We wait until N consecutive frames with
+    // 0 loads (convergence) before starting the orbit sweep, capped by
+    // MAX_WARM_FRAMES so chronically thrashing scenes still produce
+    // numbers. Both reset implicitly per bench run via setBenchmarkFrames.
+    int  bench_warm_streak_          = 0;
+    int  bench_warm_frames_total_    = 0;
+    bool bench_warm_done_            = false;  // latch: once true, gate is open for this run
+
 private:
 
     // Switch to LOD1 when an instance's projected bounding-sphere radius
@@ -495,6 +510,7 @@ private:
     // distinct slice of render() so we can attribute frame cost. Totals
     // across the timed window are divided by bench_total_ on print.
     double   bench_cull_ms_total_     = 0.0;
+    double   bench_stream_ms_total_   = 0.0;  // driveStreamingLoads only
     double   bench_hiz_readback_ms_total_ = 0.0;
     double   bench_submit_ms_total_   = 0.0;
 };