fix(precision): keep typed coordinates exact in f64 (#311)

Typed values were quantized to the f32 grid before reaching the
entity (e.g. a length of 2000.8 committed as 2000.8020), worsening
with magnitude. The interaction point layer was all glam::Vec3 (f32).

Two-layer fix:

1. Coordinate backbone -> f64. last_point, last_cursor_world,
   dyn_anchor, dyn_ref become DVec3; UcsXform transforms, parse_coord,
   the ucs helper fns, dyn_resolve_point, the OTRACK typed-distance
   paths, command-line coordinate entry and the coordinate readout all
   compute in f64. Screen/GPU/alignment stays f32 (snap engine, render
   geometry, projection, UCS-icon/viewcube drawing) with casts only at
   those boundaries.

2. Per-command committed storage -> DVec3. on_point already received a
   DVec3, but many command impls narrowed it back to f32 (let pt =
   pt.as_vec3(); Vec<Vec3> fields) and re-widened at build, quantizing
   the committed coordinate. Migrated PLINE, SPLINE, MLINE, LENGTHEN,
   INSERT, 3D primitives, every dimension/leader/mleader, ray, revcloud,
   wipeout, attdef, table, tolerance, array center, mview, plot_window,
   plus the QDIM_PLACE handler and qdim_collect_points. Preview,
   hit-test and rubber-band paths keep f32 at the boundary.

Hatch manual boundaries are left for a follow-up: HatchModel.boundary
is structurally Arc<Vec<[f32;2]>> and needs a model-level widen.

Co-Authored-By: Claude Opus 4.8 <[email protected]>

src/app/view/controls.rs

@@ -191,15 +191,15 @@ pub(super) fn viewport_controls<'a>(
 /// world position (and the base point for polar quantities).
 pub(super) fn dyn_component_value(
     f: &DynFieldEntry,
-    w: glam::Vec3,
-    base: Option<glam::Vec3>,
+    w: glam::DVec3,
+    base: Option<glam::DVec3>,
     xf: &super::super::helpers::UcsXform,
     comma_cartesian: bool,
 ) -> String {
     if let Some(b) = &f.buffer {
         return b.clone();
     }
-    let b = base.unwrap_or(glam::Vec3::ZERO);
+    let b = base.unwrap_or(glam::DVec3::ZERO);
     // Relative deltas and the polar angle read in the active UCS plane. The
     // delta is offset-invariant, so only the axis rotation matters (identity
     // xf reproduces the world-frame deltas).

src/app/view/mod.rs

@@ -200,7 +200,7 @@ impl OpenCADStudio {
             let (vw, vh) = tab.scene.selection.borrow().vp_size;
             let model_basis = {
                 let (o, ux, uy, uz) = tab.ucs_xform().axes();
-                (o.as_dvec3(), (ux, uy, uz))
+                (o, (ux.as_vec3(), uy.as_vec3(), uz.as_vec3()))
             };
             let grid: Vec<crate::ui::overlay::GridParams> = tab
                 .scene
@@ -212,7 +212,7 @@ impl OpenCADStudio {
                             Some(u) => {
                                 let (o, ux, uy, uz) =
                                     super::helpers::UcsXform::from_ucs(&u).axes();
-                                (o.as_dvec3(), (ux, uy, uz))
+                                (o, (ux.as_vec3(), uy.as_vec3(), uz.as_vec3()))
                             }
                             None => (
                                 glam::DVec3::ZERO,
@@ -345,7 +345,7 @@ impl OpenCADStudio {
                 vec![crate::ui::overlay::UcsIconParams {
                     view_proj: vp_cam.view_proj_rte(full),
                     bounds: full,
-                    axes: (ux, uy, uz),
+                    axes: (ux.as_vec3(), uy.as_vec3(), uz.as_vec3()),
                     origin_screen,
                     hover: self.ucs_icon_hover,
                     selected: self.ucs_icon_selected,
@@ -378,7 +378,7 @@ impl OpenCADStudio {
                         crate::ui::overlay::UcsIconParams {
                             view_proj: cam.view_proj_rte(b),
                             bounds: b,
-                            axes: (ux, uy, uz),
+                            axes: (ux.as_vec3(), uy.as_vec3(), uz.as_vec3()),
                             origin_screen,
                             hover: i == active && self.ucs_icon_hover,
                             selected: i == active && self.ucs_icon_selected,
@@ -440,7 +440,7 @@ impl OpenCADStudio {
                 match (otrack_proj, self.otrack_active) {
                     (Some((view_rot, eye, ob)), Some((base, _dir))) => {
                         let b = ost_project(base, view_rot, eye, ob);
-                        let a = ost_project(tab.last_cursor_world, view_rot, eye, ob);
+                        let a = ost_project(tab.last_cursor_world.as_vec3(), view_rot, eye, ob);
                         (b.x.is_finite() && a.x.is_finite()).then_some((b, a))
                     }
                     _ => None,
@@ -573,7 +573,7 @@ impl OpenCADStudio {
                 // A command may drive a typed scalar by mouse (e.g. a
                 // perpendicular distance to a picked object); show that live
                 // value in the box until the user types over it.
-                let live = tab.active_cmd.as_ref().and_then(|c| c.dyn_live_value(w.as_dvec3()));
+                let live = tab.active_cmd.as_ref().and_then(|c| c.dyn_live_value(w));
                 let boxes: Vec<crate::ui::overlay::DynBox> = tab
                     .dyn_fields
                     .iter()
@@ -1304,7 +1304,7 @@ impl OpenCADStudio {
                     // drawing coordinates (paper space carries no offset), then
                     // report it in the active UCS — the readout follows the
                     // user's coordinate system, not raw WCS (no-op without UCS).
-                    let to_readout = |p: glam::Vec3| {
+                    let to_readout = |p: glam::DVec3| {
                         // The readout follows the active pane's UCS — model space
                         // or inside a floating viewport (no-op without a UCS).
                         if tab.editing_model_space() {