feat(viewport): unify in-viewport editing on the model-space path

Replace the leaky paper-projection approach to MSPACE editing with one
coordinate adapter that routes all interaction through the viewport's own
camera — the exact camera+rect the GPU draws the content with.

- Add Scene::viewport_edit_frame(canvas) -> (camera_for_viewport,
  viewport_screen_rect): the unified adapter. Inside a floating viewport
  the viewport is the active pane, so snap/pick/grip/preview/DYN run in
  model space and land on the pixels the GPU draws. Tracks pan/zoom/twist
  exactly (twist handled by camera_from_view); crop is pixel-preserving so
  full-rect projection + cursor offset matches.
- Route snap-move, click-pick, grip-drag, grip hit-test, grip render,
  hover (HoverDwellTick), selection (single/box/poly/cycle) and command
  entity-pick through it via pick_view / cursor_model_point helpers and an
  edit_cam-aware "active pane = viewport rect" override, so the existing
  tile offset plumbing just works. Fixes wrong-object hover/selection and
  stale snap after pan/zoom.
- DYN: project anchors with the viewport camera and shift to canvas space
  so the guide/labels sit correctly (also fixes a latent tiled-model bug).
- Separate grid snap from object snap entirely: new Snapper.grid_snap_on
  flag, Grid removed from the osnap mode set, evaluated independently of
  the osnap master. Object snap never catches grid; grid corners are
  picked only when grid snap is on, at lowest priority. Default off.
- grip.rs: project_rte + grips_to_screen_rte / find_hit_grip_rte taking
  (view_rot, eye) so grips project through the composed view.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/scene/pick/grip.rs

@@ -1,7 +1,7 @@
 //! OpenCADStudio-style grip editing.
 
 use acadrust::Handle;
-use glam::DVec3;
+use glam::{DVec3, Mat4, Vec2};
 use iced::{Point, Rectangle};
 
 use crate::scene::model::object::{GripDef, GripShape};
@@ -129,3 +129,68 @@ pub fn find_hit_grip(
     }
     best
 }
+
+/// Project an f64 world point with an explicit relative-to-eye `(view_rot,
+/// eye)` pair — the camera-less form of `Camera::project_f64`. Used by the
+/// in-viewport editing path, which supplies a *composed* model→screen view
+/// (see `Scene::composed_viewport_view`) instead of a real camera.
+fn project_rte(world: DVec3, view_rot: Mat4, eye: DVec3, bounds: Rectangle) -> Option<Vec2> {
+    let rel = (world - eye).as_vec3();
+    let clip = view_rot * rel.extend(1.0);
+    if clip.w.abs() < 1e-9 {
+        return None;
+    }
+    let ndc = clip.truncate() / clip.w;
+    Some(Vec2::new(
+        (ndc.x * 0.5 + 0.5) * bounds.width,
+        (0.5 - ndc.y * 0.5) * bounds.height,
+    ))
+}
+
+/// Relative-to-eye variant of [`grips_to_screen`] taking a `(view_rot, eye)`
+/// pair instead of a `Camera`, so the composed in-viewport view can project
+/// model-space grips exactly like the GPU renders the viewport content.
+pub fn grips_to_screen_rte(
+    grips: &[GripDef],
+    view_rot: Mat4,
+    eye: DVec3,
+    bounds: Rectangle,
+) -> Vec<(usize, Point, bool, GripShape, Option<[f32; 2]>)> {
+    grips
+        .iter()
+        .map(|g| {
+            let screen = match project_rte(g.world, view_rot, eye, bounds) {
+                Some(p) => Point::new(bounds.x + p.x, bounds.y + p.y),
+                None => Point::new(f32::NAN, f32::NAN),
+            };
+            (g.id, screen, g.is_midpoint, g.shape, g.dir)
+        })
+        .collect()
+}
+
+/// Relative-to-eye variant of [`find_hit_grip`] taking a `(view_rot, eye)`
+/// pair instead of a `Camera`, for in-viewport (MSPACE) grip hit-testing.
+pub fn find_hit_grip_rte(
+    cursor: Point,
+    grips: &[GripDef],
+    view_rot: Mat4,
+    eye: DVec3,
+    bounds: Rectangle,
+) -> Option<(usize, bool, DVec3)> {
+    let mut best_dist = GRIP_THRESHOLD_PX;
+    let mut best: Option<(usize, bool, DVec3)> = None;
+
+    for g in grips {
+        let Some(screen) = project_rte(g.world, view_rot, eye, bounds) else {
+            continue;
+        };
+        let dx = screen.x - cursor.x;
+        let dy = screen.y - cursor.y;
+        let d = (dx * dx + dy * dy).sqrt();
+        if d < best_dist {
+            best_dist = d;
+            best = Some((g.id, g.is_midpoint, g.world));
+        }
+    }
+    best
+}