wgpu backend: chunk vertex storage to fit browser limits + settle frame

Two pieces:

1. Per-chunk vertex storage (stage 13)
   WebGPU mandates maxStorageBufferBindingSize ≥ 128 MB. Real BIM models
   routinely exceed that (one of yours is 139 MB vertex). Without
   chunking, every browser load would fail with
   "exceeds max_storage_buffer_binding_size".

   Strategy: each model's vertex data is split into ≤ 128 MB chunks at
   applyCachedModel time. Each chunk gets its own vertex_storage buffer,
   visible_draws / prefix_sums buffers, per_chunk_uniform, and bind group.
   Index buffer, instance storage, and mesh storage stay single-per-model
   (they fit well under the cap on every scene we've seen). Mesh-to-chunk
   assignment is bake-time-deterministic (walks meshes in order, opens a
   new chunk when adding the next would overflow).

   Cull buckets visible instances by their mesh's chunk; render issues
   one drawcall per non-empty chunk per model. WGSL is unchanged — the
   binary-search vertex pulling works identically per chunk because
   base_vertex is now CHUNK-LOCAL (the chunk's bind group binds its own
   vertex_storage).

   Single code path: chunking is ALWAYS on at 128 MB regardless of
   target. Cost on desktop is a handful of extra drawcalls per frame
   (1 per non-empty chunk; typical models = 1-3 chunks). Negligible.

   A mesh whose vertex range is itself > 128 MB can't fit in any chunk
   and would need splitting — typical IFC meshes are nowhere near that
   (hundreds of verts), and applyCachedModel warns loudly if one ever
   appears.

   --web-limits CLI flag requests the WebGPU mandatory floor limits
   (128 MB max storage binding, 256 MB max buffer) instead of the
   adapter's actual max. Used to verify chunking actually fits through
   browser constraints — turns "trust me, web will work" into a hard
   test. The 139 MB scene loads cleanly with --web-limits.

2. Settle frame after motion (bug fix)
   Reported regression: after orbiting, sub-pixel instances dropped by
   motion-mode contribution culling stayed missing after the camera
   stopped. Event-driven rendering means no frame is scheduled after
   mouse-up, so the cull never re-ran at the still threshold.

   Fix: track last_cull_was_motion_. If this frame used the motion
   threshold, requestUpdate() after present to schedule one settle
   frame. Next frame: camera_moved = false → still threshold → small
   instances reappear. Matches GL's last_cull_was_motion_ behaviour.

Verified pixel-identical on basic.ifc; loads the user's dense scene
successfully under --web-limits (chunks=2 on the 139 MB model,
chunks=1 on the others).

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

src/ifcviewer-wgpu/WgpuViewportWindow.h

@@ -352,6 +352,12 @@ public:
     // + readback + cull test entirely (matches IFC_NO_HIZ in the GL backend).
     bool hiz_enabled_ = true;
 
+    // When true, initWgpu requests the WebGPU mandatory floor limits
+    // (maxStorageBufferBindingSize=128MB, maxBufferSize=256MB) instead of
+    // the adapter's actual maximum. Use this to verify on desktop that a
+    // scene fits through the constraints a browser will impose.
+    bool web_limits_ = false;
+
 private:
 
     // Switch to LOD1 when an instance's projected bounding-sphere radius
@@ -384,6 +390,14 @@ private:
     float prev_camera_pitch_deg_   = 0.0f;
     bool  has_prev_camera_         = false;
 
+    // True iff the last cull used the motion threshold. Render schedules a
+    // single settle frame after motion stops so the previously dropped
+    // sub-pixel instances reappear at the still threshold. Without this,
+    // event-driven rendering would leave those instances missing forever
+    // because no further frame is requested after the user releases the
+    // mouse. Matches GL's last_cull_was_motion_ behaviour.
+    bool  last_cull_was_motion_    = false;
+
     // Pending one-shot screenshot, captured at the end of the next render().
     QString pending_screenshot_path_;
     bool    pending_screenshot_quit_ = false;