feat(pen): eraser delete-preview + pre-disable IV pan on stylus hover

Eraser preview (user request, "加一个淡一点的描边"): new EraserPreviewPainter
shows the eraser circle and a faint red outline over the committed strokes the
eraser currently overlaps, so you can see what is about to be deleted. Mounted
only in eraser mode (tool or barrel/inverted signal) with a live cursor that
follows the hovering/erasing pen; shares _eraserRadius/_pageAspect with the live
erase so preview and action always agree. Kept in its own RepaintBoundary.

Pen-feel fix (the "写字识别成单击" pan-steal): panEnabled now also requires the
last pointer to not be a stylus. Windows fires stylus HOVER before contact, so
_lastStylus is already true when the pen touches down -> the InteractiveViewer's
pan is disabled BEFORE the stroke's first move, instead of one frame late. A
2+ pointer pinch still always pans (focal translation); a finger/mouse down
flips _lastStylus back so finger-pan keeps working.

Grounded in Rnote + Saber research: Saber uses the same button detection we have
(buttons==kSecondaryButton || invertedStylus); the deeper zoom-flash / draw-vs-
pan robustness wants a Saber-style forked InteractiveViewer (single recognizer,
decide-at-start) -- scoped as the next step, not done here. 66/66 tests, linux
build green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lib/editor/canvas/ink_painters.dart

@@ -7,6 +7,7 @@
 import 'package:flutter/material.dart';
 import 'package:perfect_freehand/perfect_freehand.dart' as pf;
 
+import '../engine/stroke_eraser.dart' show strokeHit;
 import '../engine/stroke_geometry.dart' show kDefaultPenThinning;
 import 'pen_stroke.dart';
 
@@ -104,6 +105,86 @@ class StaticInkPainter extends CustomPainter {
       old.thinning != thinning;
 }
 
+/// Eraser preview: shows the eraser circle and faintly highlights the committed
+/// strokes the eraser would delete, so the user can see what is about to go.
+/// Mounted only while the eraser is the active mode and the pen is near the
+/// page; kept behind its own RepaintBoundary so it never dirties the ink layers.
+class EraserPreviewPainter extends CustomPainter {
+  EraserPreviewPainter({
+    required this.strokes,
+    required this.cursor,
+    required this.radius,
+    required this.aspect,
+    required this.pageSize,
+    this.thinning = kDefaultPenThinning,
+  });
+
+  final List<PenStroke> strokes;
+
+  /// Eraser center in normalized page coords, or null when no preview.
+  final PenPoint? cursor;
+
+  /// Eraser radius as a fraction of page width (matches the live erase test).
+  final double radius;
+
+  /// Page aspect (height / width) so the on-screen circle stays round.
+  final double aspect;
+
+  final Size pageSize;
+  final double thinning;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final c = cursor;
+    if (c == null) return;
+
+    // Faint outline on each stroke the eraser currently overlaps.
+    final highlight = Paint()
+      ..color = const Color(0xFFFF5252).withValues(alpha: 0.55)
+      ..style = PaintingStyle.stroke
+      ..strokeWidth = 1.5
+      ..isAntiAlias = true;
+    for (final stroke in strokes) {
+      if (!strokeHit(stroke, c.x, c.y, radius, aspect: aspect)) continue;
+      final path =
+          buildStrokePath(stroke, pageSize, isComplete: true, thinning: thinning);
+      if (path.getBounds().isEmpty) continue;
+      canvas.drawPath(path, highlight);
+    }
+
+    // The eraser circle itself (radius is a page-width fraction → px = r * w).
+    final center = Offset(c.x * pageSize.width, c.y * pageSize.height);
+    final rPx = radius * pageSize.width;
+    canvas.drawCircle(
+      center,
+      rPx,
+      Paint()
+        ..color = const Color(0xFF9E9E9E).withValues(alpha: 0.5)
+        ..style = PaintingStyle.stroke
+        ..strokeWidth = 1.0
+        ..isAntiAlias = true,
+    );
+    canvas.drawCircle(
+      center,
+      rPx,
+      Paint()
+        ..color = const Color(0x14000000)
+        ..style = PaintingStyle.fill,
+    );
+  }
+
+  @override
+  bool shouldRepaint(EraserPreviewPainter old) =>
+      old.cursor?.x != cursor?.x ||
+      old.cursor?.y != cursor?.y ||
+      old.radius != radius ||
+      old.aspect != aspect ||
+      !identical(old.strokes, strokes) ||
+      old.strokes.length != strokes.length ||
+      old.pageSize != pageSize ||
+      old.thinning != thinning;
+}
+
 /// Paints just the in-progress stroke (the live layer), kept behind its own
 /// RepaintBoundary so committed strokes don't repaint on every move.
 class LiveInkPainter extends CustomPainter {