feat(viewport): tile-relative input + overlays in unified model

Route every per-frame interaction through the active model tile's screen
rectangle so a tiled VPORTS layout behaves like independent panes while
still sharing one shader widget:

- pick / draw / snap / box+lasso: cursor mapped to tile-local space; the
  hover-activates-tile rule on ViewportMove keeps the active tile under
  the cursor, so the picked camera matches what the user sees.
- pan: switched to Camera::pan_screen(dx, dy, viewport_height) so the
  world-per-pixel rate matches the active tile's height instead of the
  full canvas.
- grid: clipped via Frame::with_clip to the active tile rect; world→screen
  adds the tile origin so the lines align with the panel.
- UCS icon: origin offset by the tile rect so the gizmo sits in the
  active tile's bottom-left corner.
- render-mode picker (+ split buttons) and ViewCube hit-area: positioned
  via active_model_tile_bounds with leading Spaces, mirroring the
  floating-viewport pattern.
- ViewCube hover: driven by the CursorMoved/ViewportMove handlers into a
  new Scene::viewcube_hover cell, so the highlight survives the cube
  hit-area overlay masking events from shader::Program::update.

Co-Authored-By: Claude Opus 4.7 <[email protected]>

src/scene/camera.rs

@@ -234,12 +234,20 @@ impl Camera {
         self.target += before - after;
     }
 
-    pub fn pan(&mut self, delta_x: f32, delta_y: f32) {
-        let speed = self.distance * 0.001;
+    /// Pan so the world point under the cursor tracks it: screen pixels are
+    /// converted to world units via the ortho world-per-pixel scale of a
+    /// viewport `viewport_height` pixels tall. Used by tiled panes where the
+    /// pane height differs from the full canvas.
+    pub fn pan_screen(&mut self, delta_x: f32, delta_y: f32, viewport_height: f32) {
+        let wpp = if viewport_height > 0.0 {
+            (2.0 * self.ortho_size()) / viewport_height
+        } else {
+            0.0
+        };
         let cam_right = self.rotation * Vec3::X;
         let cam_up = self.rotation * Vec3::Y;
-        self.target -= cam_right * delta_x * speed;
-        self.target += cam_up * delta_y * speed;
+        self.target -= cam_right * delta_x * wpp;
+        self.target += cam_up * delta_y * wpp;
     }
 
     pub fn fit_to_bounds(&mut self, min: Vec3, max: Vec3) {