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.h

@@ -0,0 +1,100 @@
+/********************************************************************************
+ *                                                                              *
+ * 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/>.         *
+ *                                                                              *
+ ********************************************************************************/
+
+#ifndef WGPUSTREAMINGTHREAD_H
+#define WGPUSTREAMINGTHREAD_H
+
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+// Worker thread for scatter-gather chunk reads. Decouples disk I/O
+// (~tens of ms per chunk on SSD, hundreds on slower media) from the
+// render thread. The viewport's per-frame driveStreamingLoads enqueues
+// requests for non-resident-frustum-visible chunks, drains any
+// completed Results on subsequent frames, and only performs the
+// GPU-side (pool.alloc + queueWriteBuffer + bind-group build) work
+// on the main thread — wgpu queue ops aren't thread-safe.
+//
+// Lifetime: start() spawns the worker; stop() signals shutdown and
+// joins. The Result destructor releases its byte vectors back to the
+// heap, so dropping unclaimed Results (e.g. when their model was
+// unloaded mid-flight) is a free operation.
+class WgpuStreamingThread {
+public:
+    struct Request {
+        uint32_t                                       model_id;
+        std::size_t                                    chunk_idx;
+        std::string                                    file_path;
+        uint64_t                                       vertex_section_offset;
+        uint64_t                                       index_section_offset;
+        // (section-relative byte_offset, byte_size)
+        std::vector<std::pair<uint64_t, uint64_t>>     v_ranges;
+        // (first_u32, count_u32)
+        std::vector<std::pair<uint64_t, uint64_t>>     i_ranges;
+    };
+
+    struct Result {
+        uint32_t              model_id;
+        std::size_t           chunk_idx;
+        bool                  success;
+        std::vector<uint8_t>  vbytes;
+        std::vector<uint32_t> idx;
+    };
+
+    ~WgpuStreamingThread();
+
+    // Spawn the worker thread. Safe to call once; subsequent calls are
+    // no-ops while the worker is alive.
+    void start();
+    // Signal shutdown, wake the worker, join. Idempotent. Must be
+    // called before the WgpuBufferPool the results would upload into
+    // is destroyed.
+    void stop();
+
+    // Enqueue a request. Returns false if the worker has stopped.
+    bool enqueue(Request req);
+    // Move all completed results out of the result queue. Always
+    // non-blocking; if nothing is ready, returns an empty vector.
+    std::vector<Result> drainResults();
+
+    // Approximate count of requests still in flight (in queue or
+    // currently being processed). Useful for the bench warm gate to
+    // know when streaming has truly settled.
+    std::size_t inFlightApprox() const;
+
+private:
+    void workerLoop();
+
+    std::thread             worker_;
+    mutable std::mutex      mu_;
+    std::condition_variable cv_;
+    std::deque<Request>     requests_;
+    std::deque<Result>      results_;
+    bool                    in_progress_ = false;
+    bool                    shutdown_    = false;
+    bool                    running_     = false;
+};
+
+#endif  // WGPUSTREAMINGTHREAD_H