feat: Spline support for TRIM, EXTEND, OFFSET, BREAK, and LENGTHEN

Add shared spline_ops module with:
- spline_to_bspline / bspline_to_spline: acadrust ↔ truck BSplineCurve conversion
- spline_sample_xy: sample DXF-XY projection at N+1 points with parameters
- spline_nearest_t: nearest-parameter search via coarse+bisection
- spline_pts_wire: world-space wire points for WireModel preview

TRIM: Spline entities can now be used as cutting boundaries (Geo::Spline
sampled into polyline segments) and as entities being trimmed; uses
BSplineCurve::cut() to produce surviving pieces.

EXTEND: extend_spline() shoots a tangent ray from the nearest endpoint
and appends a control point at the first boundary hit.

OFFSET: offset_spline() offsets each sample point along the local
perpendicular normal and rebuilds a new spline from the offset control pts.

BREAK: break_spline() uses spline_nearest_t() + BSplineCurve::cut() to
split the spline at one or two click points.

LENGTHEN: lengthen_spline() uses numerical arc-length integration +
bisection to cut the spline at the parameter corresponding to the new
requested length.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/modules/home/modify/spline_ops.rs

@@ -0,0 +1,138 @@
+// Shared B-spline utilities for modify commands (TRIM, BREAK, OFFSET, LENGTHEN).
+//
+// Provides:
+//   - spline_to_bspline   : acadrust Spline → truck BSplineCurve<Point3>
+//   - bspline_to_spline   : truck BSplineCurve<Point3> → acadrust Spline
+//   - spline_sample_xy    : sample the DXF-XY projection at N+1 points (with t params)
+//   - spline_nearest_t    : find the spline parameter t closest to a DXF-XY click
+//   - spline_pts_wire     : world-space wire points for WireModel preview
+
+use acadrust::entities::Spline;
+use acadrust::types::Vector3;
+use acadrust::Handle;
+use truck_modeling::{BSplineCurve, KnotVec, Point3};
+use truck_modeling::base::{BoundedCurve, ParametricCurve};
+
+// ── Conversion ─────────────────────────────────────────────────────────────
+
+/// Convert an acadrust `Spline` to a truck `BSplineCurve<Point3>`.
+/// Returns `None` if the spline has too few control points or inconsistent data.
+pub fn spline_to_bspline(spl: &Spline) -> Option<BSplineCurve<Point3>> {
+    let ctrl_pts: Vec<Point3> = spl
+        .control_points
+        .iter()
+        .map(|p| Point3::new(p.x, p.y, p.z))
+        .collect();
+    if ctrl_pts.len() < 2 {
+        return None;
+    }
+    let degree = spl.degree as usize;
+    let expected_knots = ctrl_pts.len() + degree + 1;
+    let knot_vec = if spl.knots.len() == expected_knots {
+        KnotVec::from(spl.knots.clone())
+    } else {
+        KnotVec::uniform_knot(degree, ctrl_pts.len() - 1)
+    };
+    Some(BSplineCurve::new(knot_vec, ctrl_pts))
+}
+
+/// Rebuild an acadrust `Spline` from a trimmed `BSplineCurve<Point3>`.
+/// The `template` spline provides the entity common data, degree, and Z-elevation.
+pub fn bspline_to_spline(bs: &BSplineCurve<Point3>, template: &Spline) -> Spline {
+    let z = template
+        .control_points
+        .first()
+        .map(|v| v.z)
+        .unwrap_or(0.0);
+    let mut spl = template.clone();
+    spl.common.handle = Handle::NULL;
+    spl.degree = bs.degree() as i32;
+    spl.knots = bs.knot_vec().iter().copied().collect();
+    spl.control_points = bs
+        .control_points()
+        .iter()
+        .map(|p| Vector3::new(p.x, p.y, z))
+        .collect();
+    spl.weights.clear();   // not rational after split
+    spl.fit_points.clear(); // fit points are no longer valid
+    spl
+}
+
+// ── Sampling ───────────────────────────────────────────────────────────────
+
+/// Sample the spline's DXF-XY projection at `n+1` evenly-spaced parameter
+/// values.  Returns `(t_params, xy_points)` both of length `n+1`.
+pub fn spline_sample_xy(spl: &Spline, n: usize) -> (Vec<f64>, Vec<[f64; 2]>) {
+    let bs = match spline_to_bspline(spl) {
+        Some(b) => b,
+        None => return (vec![], vec![]),
+    };
+    let (t0, t1) = bs.range_tuple();
+    let ts: Vec<f64> = (0..=n)
+        .map(|i| t0 + (t1 - t0) * (i as f64 / n as f64))
+        .collect();
+    let pts: Vec<[f64; 2]> = ts.iter().map(|&t| {
+        let p = bs.subs(t);
+        [p.x, p.y]
+    }).collect();
+    (ts, pts)
+}
+
+/// Find the spline parameter `t` (in the knot-vector range [t0, t1]) that is
+/// closest to the DXF-XY point `(x, y)`.
+/// Uses 64-sample coarse search followed by bisection.
+pub fn spline_nearest_t(spl: &Spline, x: f64, y: f64) -> Option<f64> {
+    let bs = spline_to_bspline(spl)?;
+    let (t0, t1) = bs.range_tuple();
+    let n = 64usize;
+    let step = (t1 - t0) / n as f64;
+
+    // Coarse search
+    let mut best_t = t0;
+    let mut best_d = f64::MAX;
+    for i in 0..=n {
+        let t = t0 + i as f64 * step;
+        let p = bs.subs(t);
+        let d = (p.x - x).powi(2) + (p.y - y).powi(2);
+        if d < best_d {
+            best_d = d;
+            best_t = t;
+        }
+    }
+
+    // Bisection refinement in [best_t - step, best_t + step]
+    let lo = (best_t - step).max(t0);
+    let hi = (best_t + step).min(t1);
+    let mut a = lo;
+    let mut b = hi;
+    for _ in 0..32 {
+        let m1 = a + (b - a) / 3.0;
+        let m2 = b - (b - a) / 3.0;
+        let p1 = bs.subs(m1);
+        let p2 = bs.subs(m2);
+        let d1 = (p1.x - x).powi(2) + (p1.y - y).powi(2);
+        let d2 = (p2.x - x).powi(2) + (p2.y - y).powi(2);
+        if d1 < d2 { b = m2; } else { a = m1; }
+    }
+    Some((a + b) * 0.5)
+}
+
+/// Returns the normalised parameter in [0, 1] given an actual B-spline
+/// parameter `t_actual` and the range `[t0, t1]`.
+pub fn t_to_rel(t_actual: f64, t0: f64, t1: f64) -> f64 {
+    if (t1 - t0).abs() < 1e-12 { return 0.0; }
+    ((t_actual - t0) / (t1 - t0)).clamp(0.0, 1.0)
+}
+
+// ── Wire preview ───────────────────────────────────────────────────────────
+
+/// World-space wire points for a Spline (samples 64 segments).
+/// Y-up convention: world (x, 0, y) for DXF (x, y).
+pub fn spline_pts_wire(spl: &Spline) -> Vec<[f32; 3]> {
+    let (_, pts) = spline_sample_xy(spl, 64);
+    if pts.is_empty() { return vec![]; }
+    let elev = spl.control_points.first().map(|v| v.z as f32).unwrap_or(0.0);
+    pts.iter()
+        .map(|p| [p[0] as f32, elev, p[1] as f32])
+        .collect()
+}