Add 8 geometric constraint kinds and an opt-in DWG-native persistence toggle

New ConstraintKind variants — Concentric, CenterPoint, Colinear, Midpoint,
Fixed, PointOnCurve, EqualDistance, Symmetric — each built entirely from
existing ocs_gcs (FreeCAD planegcs) primitives, no new solver math needed.
build_constraint now returns Vec<Rc<dyn Constraint>> instead of
Option<Rc<...>>, generalizing the old Coincident-only "needs a second
system-level constraint" special case to every kind that needs one.
Wired into the ribbon (7 new buttons), a new point+pre-selected-entity
command for CenterPoint/Midpoint/PointOnCurve, a new 4-point command for
EqualDistance, and the existing DWG-native class-name mapping (all 8 reuse
the same generic "plain Geometrical node" path already built for
Coincident/Horizontal/etc.). Deliberately not modeled: Normal and
EqualCurvature, which for this app's Line/Circle-only entity model would
just be Perpendicular and Equal wearing different DWG class names.

Also makes DWG-native constraint persistence opt-in (Options > General,
off by default) rather than unconditional: a scope that doesn't yet have
the native graph is only given one when the setting is on, but a scope
that already has one — from an earlier save, or a file that came from
real AutoCAD — keeps getting it resynced regardless of the setting, so
toggling it off never freezes a stale graph in place.

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

src/modules/draw/constrain/point_on_entity.rs

@@ -0,0 +1,91 @@
+//! CENTERPOINT / MIDPOINT / ONCURVE — constraints between one picked point
+//! and a whole entity selected *before* the tool runs (same "select first,
+//! then invoke" convention `DistanceConstraintCommand`
+//! (`src/modules/draw/constrain/value.rs`) already uses for its own target
+//! entity). The entity side has no ambiguity (a whole circle, or a whole
+//! line whose midpoint/curve is being addressed, not one specific
+//! endpoint) so it doesn't need interactive picking; the point side does
+//! (which of a line's two endpoints, or some other addressable point), so
+//! this command accumulates just that one point pick and hands it back for
+//! the host to resolve via `nearest_sketch_point` — the same split
+//! `CoincidentConstraintCommand` uses and for the same reason (`CadCommand`
+//! has no document access).
+
+use glam::DVec3;
+
+use crate::command::{CadCommand, CmdResult};
+use crate::modules::{IconKind, ModuleEvent, ToolDef};
+use crate::scene::sketch_constraints::ConstraintKind;
+use acadrust::types::Handle;
+
+pub mod center_point_tool {
+    use super::*;
+    pub fn tool() -> ToolDef {
+        ToolDef {
+            id: "CPCONSTRAINT",
+            label: "Center Point",
+            icon: IconKind::Glyph("⊕"),
+            event: ModuleEvent::Command("CPCONSTRAINT".to_string()),
+        }
+    }
+}
+
+pub mod midpoint_tool {
+    use super::*;
+    pub fn tool() -> ToolDef {
+        ToolDef {
+            id: "MPCONSTRAINT",
+            label: "Midpoint",
+            icon: IconKind::Glyph("M"),
+            event: ModuleEvent::Command("MPCONSTRAINT".to_string()),
+        }
+    }
+}
+
+pub mod point_on_curve_tool {
+    use super::*;
+    pub fn tool() -> ToolDef {
+        ToolDef {
+            id: "OCCONSTRAINT",
+            label: "Point on Curve",
+            icon: IconKind::Glyph("∈"),
+            event: ModuleEvent::Command("OCCONSTRAINT".to_string()),
+        }
+    }
+}
+
+/// Shared by all three tools above — only `name`/`kind`/`label` differ.
+pub struct PointOnEntityConstraintCommand {
+    name: &'static str,
+    kind: ConstraintKind,
+    target: Handle,
+    label: &'static str,
+}
+
+impl PointOnEntityConstraintCommand {
+    pub fn new(name: &'static str, kind: ConstraintKind, target: Handle, label: &'static str) -> Self {
+        Self { name, kind, target, label }
+    }
+}
+
+impl CadCommand for PointOnEntityConstraintCommand {
+    fn name(&self) -> &'static str {
+        self.name
+    }
+
+    fn prompt(&self) -> String {
+        "Specify point:".to_string()
+    }
+
+    fn on_point(&mut self, pt: DVec3) -> CmdResult {
+        CmdResult::AddPointOnEntityConstraint { point: pt, target: self.target, kind: self.kind, label: self.label }
+    }
+
+    fn on_enter(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+
+    fn on_escape(&mut self) -> CmdResult {
+        CmdResult::Cancel
+    }
+}