render: watertight ray picking, element face ids and an overlay layer

The pick module tests rays against triangles with the watertight
ray-triangle intersection of Woop, Benthin and Wald (JCGT 2013): a ray
through an edge or vertex two triangles share hits one of them, the
nearest hit wins and ties go to the lower index, so picks are
deterministic. A Projector holds the camera's projection for
screen-space picks (Camera::to_screen and the CPU renderer use it too),
and a DepthMap of the drawn faces, rasterised by the renderer's own
triangle routine, tells which points are in front (box selection).

Display triangles now carry their element and face number (numbered as
ElementKind::faces numbers them; seen_face gives a shell's bottom side
from behind), line elements their element, and geometry surface
triangles their face tag, so a hit names what a set refers to.
DisplayMesh::pick (results probing) uses the new test.

render_layers draws a second scene over the first: its faces over the
scene faces they repeat (a small depth allowance), then its lines and
points. The viewport draws selection and hover highlights with it
without rebuilding the model's scene.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

crates/render/src/camera.rs

@@ -5,6 +5,7 @@
 
 use serde::{Deserialize, Serialize};
 
+use crate::pick::Projector;
 use crate::{Aabb3, Vec3};
 
 /// Column-major 4×4 matrix.
@@ -206,13 +207,9 @@ impl Camera {
         self.proj(aspect, n, f).mul(&self.view())
     }
     /// World point → pixel coordinates (x right, y down) and depth (0 near … 1 far).
+    /// For many points, a [`Projector`] computes the projection once.
     pub fn to_screen(&self, p: Vec3, w: f64, h: f64, radius: f64) -> Option<(f64, f64, f64)> {
-        let c = self.view_proj(w / h.max(1.0), radius).apply(p);
-        if c[3].abs() < 1e-12 {
-            return None;
-        }
-        let (x, y, z) = (c[0] / c[3], c[1] / c[3], c[2] / c[3]);
-        (c[3] > 0.0).then_some(((x + 1.0) * 0.5 * w, (1.0 - y) * 0.5 * h, z))
+        Projector::new(self, w, h, radius).screen(p).map(|[x, y, z]| (x, y, z))
     }
     /// Picking ray through pixel (x, y): origin and unit direction.
     pub fn ray(&self, x: f64, y: f64, w: f64, h: f64) -> (Vec3, Vec3) {