Feat: Phase 5 — MLine, Tolerance render; DimStyle Choice picker on dimensions

- mline.rs: MLine renders center spine + two parallel offset lines at
  ±scale/2 using the vertex miter directions; vertex grips; scale,
  closed and style-name properties
- tolerance.rs: Tolerance renders the GDT text string via font
  tessellation at insertion_point with rotation from direction vector;
  insertion grip and position properties
- properties.rs: Dimension entity's style_name EditText is upgraded to
  a Choice dropdown when document.dim_styles is non-empty, enabling
  point-and-click DimStyle assignment without a separate panel

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

src/entities/tolerance.rs

@@ -0,0 +1,115 @@
+use acadrust::entities::Tolerance;
+use glam::Vec3;
+
+use crate::command::EntityTransform;
+use crate::entities::common::{edit_prop as edit, ro_prop as ro, square_grip};
+use crate::entities::traits::{Grippable, PropertyEditable, Transformable, TruckConvertible};
+use crate::scene::acad_to_truck::{TruckEntity, TruckObject};
+use crate::scene::object::{GripApply, GripDef, PropSection};
+use crate::scene::wire_model::SnapHint;
+use crate::scene::{cxf, transform};
+
+impl TruckConvertible for Tolerance {
+    fn to_truck(&self, _document: &acadrust::CadDocument) -> Option<TruckEntity> {
+        if self.text.is_empty() {
+            return None;
+        }
+        // GDT tolerance text — render with the standard font.
+        // Special GDT symbols (Ⓗ, ⊕ etc.) will display as-is if the font
+        // supports them, otherwise as placeholder glyphs.
+        let snap_pt = Vec3::new(
+            self.insertion_point.x as f32,
+            self.insertion_point.y as f32,
+            self.insertion_point.z as f32,
+        );
+
+        // Determine rotation from the direction vector.
+        let angle = (self.direction.y as f32).atan2(self.direction.x as f32);
+        // Use a default height of 2.5 (standard annotation size).
+        let height = 2.5_f32;
+
+        let strokes = cxf::tessellate_text_ex(
+            [self.insertion_point.x as f32, self.insertion_point.y as f32],
+            height,
+            angle,
+            1.0,
+            0.0,
+            "txt", // standard CAD font
+            &self.text,
+        );
+
+        Some(TruckEntity {
+            object: TruckObject::Text(strokes),
+            snap_pts: vec![(snap_pt, SnapHint::Insertion)],
+            tangent_geoms: vec![],
+            key_vertices: vec![],
+        })
+    }
+}
+
+impl Grippable for Tolerance {
+    fn grips(&self) -> Vec<GripDef> {
+        vec![square_grip(
+            0,
+            Vec3::new(
+                self.insertion_point.x as f32,
+                self.insertion_point.y as f32,
+                self.insertion_point.z as f32,
+            ),
+        )]
+    }
+
+    fn apply_grip(&mut self, grip_id: usize, apply: GripApply) {
+        if grip_id == 0 {
+            match apply {
+                GripApply::Translate(d) => {
+                    self.insertion_point.x += d.x as f64;
+                    self.insertion_point.y += d.y as f64;
+                    self.insertion_point.z += d.z as f64;
+                }
+                GripApply::Absolute(p) => {
+                    self.insertion_point.x = p.x as f64;
+                    self.insertion_point.y = p.y as f64;
+                    self.insertion_point.z = p.z as f64;
+                }
+            }
+        }
+    }
+}
+
+impl PropertyEditable for Tolerance {
+    fn geometry_properties(&self, _text_style_names: &[String]) -> PropSection {
+        PropSection {
+            title: "Geometry".into(),
+            props: vec![
+                ro("Text", "tol_text", self.text.clone()),
+                edit("Insert X", "tol_ix", self.insertion_point.x),
+                edit("Insert Y", "tol_iy", self.insertion_point.y),
+                edit("Insert Z", "tol_iz", self.insertion_point.z),
+            ],
+        }
+    }
+
+    fn apply_geom_prop(&mut self, field: &str, value: &str) {
+        let Ok(v) = value.trim().parse::<f64>() else { return };
+        match field {
+            "tol_ix" => self.insertion_point.x = v,
+            "tol_iy" => self.insertion_point.y = v,
+            "tol_iz" => self.insertion_point.z = v,
+            _ => {}
+        }
+    }
+}
+
+impl Transformable for Tolerance {
+    fn apply_transform(&mut self, t: &EntityTransform) {
+        transform::apply_standard_entity_transform(self, t, |entity, p1, p2| {
+            transform::reflect_xy_point(
+                &mut entity.insertion_point.x,
+                &mut entity.insertion_point.y,
+                p1,
+                p2,
+            );
+        });
+    }
+}