perf(scene): multi-resolution mesh LOD (Phase 3.4)

ACIS SAT entities (Solid3D / Region / Body) were tessellated at one
fixed sampling density (CIRC_SEGS=48, GRID_U=32, GRID_V=16) regardless
of how far they were from the camera. Distant solids paid the full
triangle bill for fragments that mostly resolved to sub-pixel size.

Generate three pre-built LODs per entity at load time:

  * LOD 0 (HIGH)  — 48/32/16 segments. Use above 200 px projected diag.
  * LOD 1 (MID)   — 24/16/8.  Use 50–200 px.
  * LOD 2 (LOW)   — 12/8/4.   Use below 50 px.

Tessellation cost is paid 3× on load (cheap — typical files have few
solids). Render picks per-frame via `compute_mesh_lod` from each mesh's
`world_aabb` projected diagonal. When a level is missing (e.g. a solid
entity that only emits LOD 0), the selector walks down to the nearest
available slot.

API ripples:
  * New `LodConfig` (HIGH/MID/LOW) drives `tess_sat`, `tess_cone_face`,
    `tess_sphere_face`, `tess_torus_face`.
  * `tessellate_solid3d / _region / _body` now return `MeshLodSet`.
  * `MeshLodSet { lods: Vec<MeshModel>, world_aabb }` + `from_single`
    constructor so interactive truck-based commands (BOX/CYLINDER/etc.)
    that only generate one tessellation stay one-line.
  * GPU side gets `MeshLodGpu { lods: Vec<MeshGpu>, world_aabb }` and
    a `mesh_lod_levels` per-frame index vector.
  * STL/STEP export pulls slot 0 explicitly so the on-disk geometry
    isn't downgraded by the view-dependent ladder.

Background-thread lazy generation (per the roadmap) is deferred — the
synchronous eager build is fine for typical CAD files. Switch to a
queue + background tessellator when files with hundreds of solids
become a load-time bottleneck.

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

src/scene/mesh_model.rs

@@ -26,3 +26,50 @@ impl MeshModel {
     pub const WHITE: [f32; 4] = [1.00, 1.00, 1.00, 1.0];
     pub const SELECTED: [f32; 4] = [0.15, 0.55, 1.00, 1.0];
 }
+
+/// Bundle of mesh tessellations at different sampling densities, picked
+/// per frame by the render pipeline based on the projected pixel size of
+/// `world_aabb`. Phase 3.4 LOD ladder:
+///
+/// | LOD | Source     | Use when projected diagonal |
+/// |-----|------------|------------------------------|
+/// | 0   | HIGH       | > 200 px                     |
+/// | 1   | MID (½)    | 50–200 px                    |
+/// | 2   | LOW (¼)    | < 50 px                      |
+///
+/// `lods` holds up to one MeshModel per LOD level (high → low). Empty
+/// slots fall back to the nearest available LOD at render time.
+#[derive(Clone, Debug)]
+pub struct MeshLodSet {
+    pub lods: Vec<MeshModel>,
+    /// World XY AABB `[min_x, min_y, max_x, max_y]` of the mesh — used
+    /// by the per-frame LOD selector to compute the projected pixel
+    /// diagonal.
+    pub world_aabb: [f32; 4],
+}
+
+impl MeshLodSet {
+    /// Wrap a single MeshModel as a one-LOD set. Used by interactive
+    /// commands that only produce one tessellation (e.g. truck-based
+    /// BOX/CYLINDER creation). The LOD selector will pick slot 0 for
+    /// every zoom level.
+    pub fn from_single(mesh: MeshModel) -> Self {
+        let mut min_x = f32::INFINITY;
+        let mut min_y = f32::INFINITY;
+        let mut max_x = f32::NEG_INFINITY;
+        let mut max_y = f32::NEG_INFINITY;
+        for &[x, y, _] in &mesh.verts {
+            if !x.is_finite() || !y.is_finite() {
+                continue;
+            }
+            if x < min_x { min_x = x; }
+            if y < min_y { min_y = y; }
+            if x > max_x { max_x = x; }
+            if y > max_y { max_y = y; }
+        }
+        Self {
+            lods: vec![mesh],
+            world_aabb: [min_x, min_y, max_x, max_y],
+        }
+    }
+}