refactor: merge ifcviewer-wgpu into ifcviewer, drop Wgpu prefix

The GL backend is gone (task #53). The wgpu/non-wgpu folder split and
the Wgpu* class prefix were both disambiguation artefacts from the
overlap period — now pure dead weight.

## Folder + library merge

* `src/ifcviewer-wgpu/`  → folded into `src/ifcviewer/` (git mv tracks
  every file as a rename so blame/log history survives).
* `src/ifcviewer-wgpu-minimal/` → `src/ifcviewer-minimal/` (the exe was
  already named `IfcViewerMinimal`; this just brings the folder + CMake
  target name into line).
* `src/ifcviewer-wgpu/tests/test_wgpu_{selection,visibility}.cpp` →
  `src/ifcviewer/tests/test_{selection,visibility}.cpp`, folded into
  the existing `add_ifcviewer_unit_test(...)` helper.
* The `IfcViewerWgpu` static library is dissolved — its sources become
  part of the unified `IfcViewer` static library, which now bundles
  scene/loader + renderer in one target. The pre-merge circular
  dependency (IfcViewer linking IfcViewerWgpu just to get the
  ViewportWindow.h include path that SceneLoader.h needs) goes away.
* The wgpu-native FetchContent block, the Cocoa/QuartzCore link on
  Apple, the OBJCXX-enabled `.mm` source, and the wgpu-native runtime
  install all move into `src/ifcviewer/CMakeLists.txt` unchanged.

## Type renames (Wgpu prefix dropped from every Wgpu* identifier)

  WgpuAreaMeasurement   → AreaMeasurement
  WgpuBufferPool        → BufferPool
  WgpuLengthMeasurement → LengthMeasurement
  WgpuMetalSurface      → MetalSurface
  WgpuModelGpuData      → ModelGpuData
  WgpuOverlayFrame      → OverlayFrame
  WgpuOverlayRenderer   → OverlayRenderer
  WgpuSectionPlane      → SectionPlane
  WgpuSelectionState    → SelectionState
  WgpuStreamingLoader   → StreamingLoader
  WgpuStreamingThread   → StreamingThread
  WgpuViewportWindow    → ViewportWindow
  WgpuVisibilityState   → VisibilityState

  CMake target IfcViewerWgpuMinimal → IfcViewerMinimal (exe name was
  already this since wgpu shipped as default).

Deliberately kept: `onWgpuLog` (wgpu-native log callback — names a
binding to an external API, not one of *our* types), and the WGPU*
enum/struct prefixes from wgpu-native's own headers. `WgpuMemProbe`
lives in the separate `src/wgpu-mem-probe/` standalone diagnostic
project and isn't touched.

## Include-path updates

Every `#include "../ifcviewer-wgpu/Wgpu<X>.h"` → `"../ifcviewer/<X>.h"`,
every in-directory `#include "Wgpu<X>.h"` → `"<X>.h"`. Includes from
sibling subdirectories (modules/, etc.) are updated to point at
`../../../ifcviewer/` instead of `../../../ifcviewer-wgpu/`.

## cmake/CMakeLists.txt simplification

The redundant `add_subdirectory(ifcviewer-wgpu)` blocks (one inside
the BUILD_BONSAIVIEWER fan-in, one in the BONSAIVIEWER-less standalone
block) collapse into a single unconditional
`add_subdirectory(../src/ifcviewer ifcviewer)`. The standalone block
keeps only `wgpu-mem-probe` (the diagnostic tool, unrelated to the
viewer lib).

## Verification

* Full build green: `IfcViewer` static lib, `IfcViewerMinimal` exe,
  `BonsaiViewer` exe, all four pre-existing ifcviewer unit tests, and
  the two new-location tests (`test_selection`, `test_visibility`).
* No stray `Wgpu<X>` identifier remains across `src/ifcviewer/`,
  `src/bonsaiviewer/`, `src/ifcviewer-minimal/` (verified by grep).
* Renames tracked by git as `R` entries — `git log --follow` on
  ViewportWindow.cpp etc. continues to show history through the move.

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

src/ifcviewer/StreamingThread.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 "StreamingThread.h"
+
+#include "StreamingLoader.h"
+
+StreamingThread::~StreamingThread() {
+    stop();
+}
+
+void StreamingThread::start() {
+    std::unique_lock lk(mu_);
+    if (running_) return;
+    shutdown_ = false;
+    running_  = true;
+    lk.unlock();
+    worker_ = std::thread(&StreamingThread::workerLoop, this);
+}
+
+void StreamingThread::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 StreamingThread::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<StreamingThread::Result> StreamingThread::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 StreamingThread::inFlightApprox() const {
+    std::unique_lock lk(mu_);
+    return requests_.size() + (in_progress_ ? 1u : 0u);
+}
+
+void StreamingThread::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;
+        }
+    }
+}