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 <noreply@anthropic.com>

src/modules/annotate/ordinate_dim.rs

@@ -28,7 +28,7 @@ pub fn tool() -> ToolDef {
 
 enum Step {
     FeaturePoint,
-    LeaderEndpoint { feature: Vec3 },
+    LeaderEndpoint { feature: DVec3 },
 }
 
 pub struct OrdinateDimCommand {
@@ -55,7 +55,7 @@ impl CadCommand for OrdinateDimCommand {
         }
     }
 
-    fn on_point(&mut self, pt: DVec3) -> CmdResult { let pt = pt.as_vec3();
+    fn on_point(&mut self, pt: DVec3) -> CmdResult {
         match self.step {
             Step::FeaturePoint => {
                 self.step = Step::LeaderEndpoint { feature: pt };
@@ -80,25 +80,30 @@ impl CadCommand for OrdinateDimCommand {
     fn on_enter(&mut self) -> CmdResult {
         CmdResult::Cancel
     }
-    fn on_mouse_move(&mut self, pt: DVec3) -> Option<WireModel> { let pt = pt.as_vec3();
+    fn on_mouse_move(&mut self, pt: DVec3) -> Option<WireModel> {
         let feature = match self.step {
             Step::LeaderEndpoint { feature } => feature,
             _ => return None,
         };
         let is_x = is_x_type(feature, pt);
         let elbow = ordinate_elbow(feature, pt, is_x);
-        Some(preview_wire(vec![feature, elbow, pt]))
+        // Screen-only rubber band: downcast to f32 at the preview boundary.
+        Some(preview_wire(vec![
+            feature.as_vec3(),
+            elbow.as_vec3(),
+            pt.as_vec3(),
+        ]))
     }
 }
 
-fn v3(p: Vec3) -> Vector3 {
-    Vector3::new(p.x as f64, p.y as f64, p.z as f64)
+fn v3(p: DVec3) -> Vector3 {
+    Vector3::new(p.x, p.y, p.z)
 }
 
 /// X-datum (labels the feature's X coordinate) when the leader runs more
 /// vertically than horizontally; Y-datum otherwise. Mirrors the placement
 /// decision so the preview and the committed entity agree.
-fn is_x_type(feature: Vec3, leader: Vec3) -> bool {
+fn is_x_type(feature: DVec3, leader: DVec3) -> bool {
     let dx = (leader.x - feature.x).abs();
     let dy = (leader.y - feature.y).abs();
     dy >= dx
@@ -106,11 +111,11 @@ fn is_x_type(feature: Vec3, leader: Vec3) -> bool {
 
 /// Orthogonal elbow of the ordinate leader: an X-datum runs along Y from the
 /// feature then jogs across in X; a Y-datum runs along X then jogs in Y.
-fn ordinate_elbow(feature: Vec3, leader: Vec3, is_x: bool) -> Vec3 {
+fn ordinate_elbow(feature: DVec3, leader: DVec3, is_x: bool) -> DVec3 {
     if is_x {
-        Vec3::new(feature.x, leader.y, feature.z)
+        DVec3::new(feature.x, leader.y, feature.z)
     } else {
-        Vec3::new(leader.x, feature.y, feature.z)
+        DVec3::new(leader.x, feature.y, feature.z)
     }
 }