Patch fills non-planar edge loops with one smooth face (#250) (#472)

* Add a one-surface fill of closed 3D loops to geom

A closed loop of curves that does not lie in a plane has no exact surface;
the usual answer is one smooth face fitted over it. fill_loop does that:

- the loop's best-fit plane (Newell normal), with a frame chosen from the
  loop itself so the result does not depend on where the loop starts, its
  direction, or where the part sits
- the loop seen along that normal must be simple and must not fold or run
  along the normal; otherwise it is refused ("not supported yet"), never
  filled with wrong geometry
- one non-rational bicubic B-spline height field over the loop's box,
  fitted by least squares to the loop's samples (The NURBS Book 9.4.1,
  9.4.3, eq. 9.62/9.65) with a thin-plate smoothness term
  lambda*A*int(h_uu^2 + 2 h_uv^2 + h_vv^2), A one grid cell's area, so the
  fit is the same at any scale; only planes are reproduced exactly
- span counts per direction (long narrow loops fit), refined until the
  loop is within tolerance, else refused with the deviation reached

bspline: bisected span search, basis functions on a stack array, one
clamping helper shared by curves and surfaces, one binomial helper.

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

* Patch fills non-planar loops of edges with one smooth face (#250)

surface.patch with edges refused any loop that is not planar ("not
supported yet: patching a loop that is not planar"). It now fills it:

- planar loops still get one exact planar face, but planarity is certified
  conservatively: lines by their ends, B-spline/NURBS edges by their control
  points, intersection curves by their samples lying on a support plane
  within tolerance; a loop that can't be certified is filled instead
- other loops get one face from geom's fill_loop, bounded by the body's own
  chained edges, whole (no split): its history is one generated face whose
  edges are the body's, and it stitches back into a closed solid
- intersection-curve edges are sampled by a seeded, guarded double
  projection shared by the planarity test and the fill (plane_fit)
- the face tolerance is 10x the planarity tolerance (documented: later
  operations take the face to contain its edges within it)
- edge picking runs inside the guard; the geom->truck conversion is shared
  with the T-spline sheets (spline_conv); the Newell plane fit is shared with
  STEP import

Tests: 3- to 8-sided, concave (dart, arrow, plus), flat-corner, two-edge and
imported rims fill as one face and stitch closed (volumes against an
independent integral); finite mesh normals, same result for any pick order
or placement; non-height-field loops and too-fine detail are refused.

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

* Test the Patch dialog filling a non-planar loop of picked edges

The Patch dialog's only test used a sketch profile. Picking the four
curved rim edges of a box cut by a sideways cylinder now makes one
surface.patch command whose result is a single smooth face over the rim.

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

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

crates/kernel/src/step_in/brep.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 
-use mt::{BoundedCurve, EuclideanSpace, InnerSpace, MetricSpace, ParametricCurve};
+use mt::{BoundedCurve, InnerSpace, MetricSpace, ParametricCurve};
 use truck_modeling as mt;
 
 use super::Ctx;
@@ -244,7 +244,7 @@ impl Builder {
             })
             .collect();
         let surface = if e.name() == "FACE" {
-            plane_through(&extent).ok_or("polygonal face without a plane")?
+            crate::plane_fit::plane_through(&extent).map(mt::Surface::Plane).ok_or("polygonal face without a plane")?
         } else {
             let sid = rid(p.get(2), "face geometry")?;
             let sense = p.get(3).and_then(Param::as_bool).unwrap_or(true);
@@ -344,30 +344,6 @@ impl Builder {
     }
 }
 
-/// Plane through a polygon (Newell's normal).
-fn plane_through(pts: &[mt::Point3]) -> Option<mt::Surface> {
-    let n = pts.len();
-    let mut nrm = mt::Vector3::new(0.0, 0.0, 0.0);
-    let mut c = mt::Vector3::new(0.0, 0.0, 0.0);
-    for i in 0..n {
-        let (a, b) = (pts.get(i)?, pts.get((i + 1) % n)?);
-        nrm.x += (a.y - b.y) * (a.z + b.z);
-        nrm.y += (a.z - b.z) * (a.x + b.x);
-        nrm.z += (a.x - b.x) * (a.y + b.y);
-        c += a.to_homogeneous().truncate();
-    }
-    let len = nrm.magnitude();
-    if !(len > 1e-12) || n == 0 {
-        return None;
-    }
-    let z = nrm / len;
-    let o = mt::Point3::from_vec(c / n as f64);
-    let a = if z.x.abs() < 0.9 { mt::Vector3::unit_x() } else { mt::Vector3::unit_y() };
-    let x = (a - z * a.dot(z)).normalize();
-    let y = z.cross(x);
-    Some(mt::Surface::Plane(mt::Plane::new(o, o + x, o + y)))
-}
-
 /// Read a solid-like representation item: MANIFOLD_SOLID_BREP, BREP_WITH_VOIDS, FACETED_BREP,
 /// or a SHELL_BASED_SURFACE_MODEL (closed shells give solids, open ones open bodies).
 pub(crate) fn read_item(cx: &Ctx, id: u64) -> R<BrepOut> {