kernel: dead code left by the port deleted; clippy -D warnings clean on all targets

No caller is left for: Assembly::sheet and assemble::outward_normal, Body::shell_nesting,
regularize_generated_planar_faces, with_shell_planar_sources, boolean_record's Traced and
of_pair, offset's normal, plane_fit's plane_through, EdgeSampler, planar_face and
plane_frame (fill has its own on the record), polyhedron's solve3, prism's wall_along,
record::regions/region, splitface's side_of_point, Analytic, analytic_face, face_sides and
canonical, surfaces::picked_loop, sweep_path's closed_path, turn and stations,
shell_groups' groups and parents with their limits, and the whole of spline_conv. Their
tests go with them: prism's curved_prism_wall_requires_positive_separable_rational_weights,
body_lump's shell_grouping_preserves_large_disconnected_patterns_and_bounds_hostile_work,
and regularization protection's check of the generated regularizer. Three names follow
clippy's conventions: into_face -> direction_into_face, from_to -> ends_along, and Params::
to_eval takes its Copy self by value; fill's clash loop walks its slots.

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

crates/kernel/src/assemble.rs

@@ -11,7 +11,7 @@
 //! normal, as the record does.
 
 use solidcraft_geom::Vec3;
-use solidcraft_geom::brep::eval::{CurveEval, SurfaceEval};
+use solidcraft_geom::brep::eval::CurveEval;
 use solidcraft_geom::brep::pcurve::{EdgeUse, pcurves_within};
 use solidcraft_geom::brep::{Brep, Curve, Curve2, Edge, Face, Loop, Natural, OrientedEdge, OrientedFace, Region, Shell, Surface, VERSION, Vertex};
 
@@ -129,18 +129,6 @@ impl Assembly {
         Ok(Assembly { tolerance: b.tolerance, vertices: b.vertices.clone(), edges, faces, regions: b.regions.clone(), shells: b.shells.len() })
     }
 
-    /// An empty sheet to build faces into: one open shell (shell 0) in the infinite region.
-    pub(crate) fn sheet(tolerance: f64) -> Assembly {
-        Assembly {
-            tolerance,
-            vertices: Vec::new(),
-            edges: Vec::new(),
-            faces: Vec::new(),
-            regions: vec![Region { shells: vec![0], void: false }],
-            shells: 1,
-        }
-    }
-
     /// A new vertex at `p`.
     pub(crate) fn vertex(&mut self, p: Vec3) -> Result<u32> {
         if !p.is_finite() {
@@ -397,13 +385,3 @@ pub(crate) fn natural_out(b: &Brep, face: usize) -> Option<bool> {
         _ => None,
     })
 }
-
-/// The outward unit normal of face `face` of `b` at the parameters of `p`, a point on it.
-pub(crate) fn outward_normal(b: &Brep, face: usize, p: Vec3) -> Option<Vec3> {
-    let f = b.faces.get(face)?;
-    let s = SurfaceEval::new(&f.surface).ok()?;
-    let uv = s.project(p, None, f64::INFINITY)?;
-    let (_, su, sv) = s.derivs(uv[0], uv[1])?;
-    let n = su.cross(sv).normalized()?;
-    Some(if natural_out(b, face)? { n } else { -n })
-}

crates/kernel/src/blend.rs

@@ -116,7 +116,7 @@ impl Faces {
 
     /// The unit direction into planar face `f` across the straight edge of `u`, square to the
     /// edge: the face lies to the left of its loop seen from its surface's natural normal.
-    pub(crate) fn into_face(&self, f: usize, u: &OrientedEdge) -> Option<Vec3> {
+    pub(crate) fn direction_into_face(&self, f: usize, u: &OrientedEdge) -> Option<Vec3> {
         let (a, b) = self.ends(u.edge as usize)?;
         let dir = if u.forward { b - a } else { a - b };
         self.natural_plane_normal(f)?.cross(dir.normalized()?).normalized()

crates/kernel/src/blend_fit.rs

@@ -322,7 +322,7 @@ fn frame(rec: &Faces, e: usize) -> Option<Frame> {
         if !uses.is_empty() {
             return None;
         }
-        beside.push((n, rec.into_face(i, u)?));
+        beside.push((n, rec.direction_into_face(i, u)?));
         chained |= rec.uses(i).filter(|x| x.edge as usize != e).any(|x| {
             let Some(other) = rec.rec.edges.get(x.edge as usize) else { return false };
             let [a, b] = other.vertices;

crates/kernel/src/blend_variable.rs

@@ -34,7 +34,7 @@ fn edge_frame(rec: &Faces, e: usize) -> Result<EdgeFrame> {
         if uses.next().is_some() {
             return None;
         }
-        rec.into_face(f, u)
+        rec.direction_into_face(f, u)
     };
     let (Some(t1), Some(t2)) = (into(i1), into(i2)) else { return Err(KernelError::Failed("blend: edge direction".into())) };
     let phi = t1.dot(t2).clamp(-1.0, 1.0).acos();

crates/kernel/src/fill.rs

@@ -155,13 +155,13 @@ fn general_fill(
     // Where a G1/G2 edge's neighbour and the one before disagree at their corner.
     let n = chain.len();
     let mut clash = vec![false; n];
-    for k in 0..n {
+    for (k, slot) in clash.iter_mut().enumerate() {
         let prev = (k + n - 1) % n;
         let (Some(Some(a)), Some(Some(b))) = (beside.get(prev), beside.get(k)) else { continue };
         let (Some(ea), Some(eb)) = (edges.get(prev), edges.get(k)) else { continue };
         let (end, start) = (ea.knots.last().copied().unwrap_or(0.0), eb.knots.first().copied().unwrap_or(0.0));
         if let (Some(x), Some(y)) = (a.across(record, end)?, b.across(record, start)?) {
-            clash[k] = x.normal.dot(y.normal).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos();
+            *slot = x.normal.dot(y.normal).abs() < (2.0 * PATCH_ANGLE_TOL_DEG).to_radians().cos();
         }
     }
     let mut across = |k: usize, ts: &[f64]| -> std::result::Result<Vec<Option<Across>>, String> {

crates/kernel/src/prism_curve.rs

@@ -35,7 +35,7 @@ impl<'a> Run<'a> {
     }
 
     /// The parameters it runs from and to.
-    fn from_to(&self) -> (f64, f64) {
+    fn ends_along(&self) -> (f64, f64) {
         let [t0, t1] = self.interval;
         if self.forward { (t0, t1) } else { (t1, t0) }
     }
@@ -123,7 +123,7 @@ fn spans_of(run: &Run, work: &mut usize) -> Option<Vec<Vec<HPoint>>> {
         }
         Curve::Ellipse { frame, radii } => {
             let (x, y) = (v3(frame.x_axis), v3(frame.y_axis));
-            let (a, b) = run.from_to();
+            let (a, b) = run.ends_along();
             return ellipse_spans(v3(frame.origin), x, y, *radii, a, b, work);
         }
         _ => return None,
@@ -315,7 +315,7 @@ fn read(run: &Run, plane: &Plane, tol: f64, work: &mut usize, each_span: bool) -
     if matches!(run.curve, Curve::SurfaceIntersection { .. }) {
         return None;
     }
-    let (ts, te) = run.from_to();
+    let (ts, te) = run.ends_along();
     if !ts.is_finite() || !te.is_finite() || run.interval[1] <= run.interval[0] {
         return None;
     }

crates/kernel/src/tess/surface.rs

@@ -34,7 +34,7 @@ pub(crate) enum Params {
 
 impl Params {
     /// The evaluator's parameters of the record's `uv`.
-    pub(crate) fn to_eval(&self, uv: [f64; 2]) -> [f64; 2] {
+    pub(crate) fn to_eval(self, uv: [f64; 2]) -> [f64; 2] {
         let [u, v] = uv;
         match self {
             Params::Same => uv,