wgpu streaming: background-thread chunk I/O kills render-thread stutters

The sync chunk-read on the render thread was causing 100-300 ms spikes
during orbit whenever a new chunk needed to scatter-gather its mesh
bytes from disk. p99 was 326 ms on the close-camera benchmark.

New WgpuStreamingThread: one worker thread with a condvar-protected
request/result queue. driveStreamingLoads becomes drain-then-enqueue:
1. Drain any results the worker pushed since last frame. For each,
   pool-allocate slices + queueWriteBuffer + build the chunk bind
   group (still main-thread because wgpu queue ops aren't thread-safe).
2. Walk visible non-resident chunks (sorted by distance), evict to
   make pool room, and enqueue the request. Chunk gains is_loading
   flag to prevent re-enqueueing while in flight.

loadChunkBytesAndUploadGpu becomes the sync fallback path, used only
when a screenshot is pending — the deferred-capture wait would
otherwise let the window manager re-layout the window between frames
and the test framework would capture at the wrong size. Normal
streaming always goes through the worker.

Bench warm-gate / requestUpdate gating updated to consider
streaming_thread_.inFlightApprox() so we don't declare "converged"
while a worker read is still in flight, and the render loop stays
alive until the worker queue is empty.

Refactored loadChunkBytesAndUploadGpu into two helpers:
- makeChunkRequest: builds the worker request from chunk metadata
- applyStreamedChunk: pool.alloc + queueWriteBuffer + bind group
Both the sync and async paths share applyStreamedChunk.

Benchmark (big federation, --streaming):
  close camera:    avg 24 fps p99 47 ms (was 27/326)
  default camera:  avg 24 fps p99 46 ms (was 31/186)
  stream time:     ~2 ms (was 8-12)
  cull is now the bottleneck (20 ms median) — task #17 (GPU compute
  cull) is the next frontier.

Pixel-identical to non-streaming on basic.ifc on both paths.

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

src/ifcviewer-wgpu/WgpuStreamingThread.cpp

@@ -0,0 +1,122 @@
+/********************************************************************************
+ *                                                                              *
+ * This file is part of IfcOpenShell.                                           *
+ *                                                                              *
+ * IfcOpenShell is free software: you can redistribute it and/or modify         *
+ * it under the terms of the Lesser GNU General Public License as published by  *
+ * the Free Software Foundation, either version 3.0 of the License, or          *
+ * (at your option) any later version.                                          *
+ *                                                                              *
+ * IfcOpenShell is distributed in the hope that it will be useful,              *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
+ * Lesser GNU General Public License for more details.                          *
+ *                                                                              *
+ * You should have received a copy of the Lesser GNU General Public License     *
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#include "WgpuStreamingThread.h"
+
+#include "WgpuStreamingLoader.h"
+
+WgpuStreamingThread::~WgpuStreamingThread() {
+    stop();
+}
+
+void WgpuStreamingThread::start() {
+    std::unique_lock lk(mu_);
+    if (running_) return;
+    shutdown_ = false;
+    running_  = true;
+    lk.unlock();
+    worker_ = std::thread(&WgpuStreamingThread::workerLoop, this);
+}
+
+void WgpuStreamingThread::stop() {
+    {
+        std::unique_lock lk(mu_);
+        if (!running_) return;
+        shutdown_ = true;
+    }
+    cv_.notify_all();
+    if (worker_.joinable()) worker_.join();
+    std::unique_lock lk(mu_);
+    running_ = false;
+    requests_.clear();
+    results_.clear();
+}
+
+bool WgpuStreamingThread::enqueue(Request req) {
+    {
+        std::unique_lock lk(mu_);
+        if (!running_ || shutdown_) return false;
+        requests_.push_back(std::move(req));
+    }
+    cv_.notify_one();
+    return true;
+}
+
+std::vector<WgpuStreamingThread::Result> WgpuStreamingThread::drainResults() {
+    std::vector<Result> out;
+    {
+        std::unique_lock lk(mu_);
+        out.reserve(results_.size());
+        while (!results_.empty()) {
+            out.push_back(std::move(results_.front()));
+            results_.pop_front();
+        }
+    }
+    return out;
+}
+
+std::size_t WgpuStreamingThread::inFlightApprox() const {
+    std::unique_lock lk(mu_);
+    return requests_.size() + (in_progress_ ? 1u : 0u);
+}
+
+void WgpuStreamingThread::workerLoop() {
+    for (;;) {
+        Request req;
+        {
+            std::unique_lock lk(mu_);
+            cv_.wait(lk, [this]() { return shutdown_ || !requests_.empty(); });
+            if (shutdown_ && requests_.empty()) return;
+            req = std::move(requests_.front());
+            requests_.pop_front();
+            in_progress_ = true;
+        }
+
+        // Disk reads happen off-thread. Each Request carries everything
+        // the reader needs; the viewport keeps the corresponding chunk
+        // marked is_loading so eviction won't yank the slot underneath
+        // us. The vbytes / idx buffers are allocated here on the worker
+        // thread — they cross back to the main thread when the result
+        // is drained and applied (pool.alloc + queueWriteBuffer).
+        Result res;
+        res.model_id  = req.model_id;
+        res.chunk_idx = req.chunk_idx;
+        res.success   = true;
+        if (!req.v_ranges.empty()) {
+            if (!readSidecarVertexRanges(req.file_path,
+                                         req.vertex_section_offset,
+                                         req.v_ranges, res.vbytes)) {
+                res.success = false;
+            }
+        }
+        if (res.success && !req.i_ranges.empty()) {
+            if (!readSidecarIndexRanges(req.file_path,
+                                        req.index_section_offset,
+                                        req.i_ranges, res.idx)) {
+                res.success = false;
+            }
+        }
+
+        {
+            std::unique_lock lk(mu_);
+            results_.push_back(std::move(res));
+            in_progress_ = false;
+        }
+    }
+}