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/modules/insert/insert_block.rs

@@ -135,14 +135,11 @@ impl CadCommand for InsertBlockCommand {
         }
     }
 
-    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::Name => CmdResult::NeedPoint,
             Step::Point { name } => {
-                let mut ins = Insert::new(
-                    name.clone(),
-                    Vector3::new(pt.x as f64, pt.y as f64, pt.z as f64),
-                );
+                let mut ins = Insert::new(name.clone(), Vector3::new(pt.x, pt.y, pt.z));
                 ins.set_x_scale(self.x_scale);
                 ins.set_y_scale(self.y_scale);
                 ins.rotation = self.rotation_rad;

src/modules/insert/solid3d_cmds.rs

@@ -7,7 +7,7 @@
 // live in the Model tab (`modules::model::primitive_cmd`).
 
 use acadrust::{entities::Solid3D, EntityType};
-use glam::{DVec3, Vec3};
+use glam::DVec3;
 
 use crate::command::{CadCommand, CmdResult};
 
@@ -95,8 +95,8 @@ impl CadCommand for ExtrudeCommand {
 pub struct RevolveCommand {
     step: RevolveStep,
     target_handle: acadrust::Handle,
-    axis_start: Vec3,
-    axis_end: Vec3,
+    axis_start: DVec3,
+    axis_end: DVec3,
     color: [f32; 4],
 }
 
@@ -113,8 +113,8 @@ impl RevolveCommand {
         Self {
             step: RevolveStep::Pick,
             target_handle: acadrust::Handle::NULL,
-            axis_start: Vec3::ZERO,
-            axis_end: Vec3::new(0.0, 0.0, 1.0),
+            axis_start: DVec3::ZERO,
+            axis_end: DVec3::new(0.0, 0.0, 1.0),
             color,
         }
     }
@@ -143,7 +143,7 @@ impl CadCommand for RevolveCommand {
         self.step = RevolveStep::AxisStart;
         CmdResult::NeedPoint
     }
-    fn on_point(&mut self, pt: DVec3) -> CmdResult { let pt = pt.as_vec3();
+    fn on_point(&mut self, pt: DVec3) -> CmdResult {
         match self.step {
             RevolveStep::AxisStart => {
                 self.axis_start = pt;
@@ -186,8 +186,8 @@ impl RevolveCommand {
     fn make_revolve(&self, angle_deg: f32) -> CmdResult {
         CmdResult::RevolveEntity {
             handle: self.target_handle,
-            axis_start: self.axis_start.as_dvec3(),
-            axis_end: self.axis_end.as_dvec3(),
+            axis_start: self.axis_start,
+            axis_end: self.axis_end,
             angle_deg,
             color: self.color,
         }