feat(editor): pen canvas + Material You UI

Clean-room reimplementation of Saber's input model: we own the gesture
pipeline so pen draws with real pressure (perfect_freehand), two-finger
pinch zooms/pans, and palm is rejected (stylus-priority, 2nd-pointer
cancels stroke). pdfrx renders one page at a time (PdfPageView, no
gestures) under a shared transform; page-based nav. Material You theme
via dynamic_color (system accent + seed fallback) and a floating tonal
tool palette + page pill. Old pdfrx-overlay spike no longer wired.

lib/editor/canvas/ink_painters.dart

@@ -0,0 +1,113 @@
+// lib/editor/canvas/ink_painters.dart
+//
+// CustomPainters for the ink layers. Strokes are stored in normalized page
+// coordinates; both painters receive the on-screen page [Size] and scale
+// points into pixels at paint time. perfect_freehand produces the outline.
+
+import 'package:flutter/material.dart';
+import 'package:perfect_freehand/perfect_freehand.dart' as pf;
+
+import 'pen_stroke.dart';
+
+/// Builds a filled outline [Path] for one stroke (already scaled to pixels).
+///
+/// [pageSize] maps normalized coords to pixels. [isComplete] should be false
+/// for the in-progress live stroke so freehand tapers correctly.
+Path buildStrokePath(PenStroke stroke, Size pageSize, {required bool isComplete}) {
+  final pixelWidth = stroke.width * pageSize.width;
+
+  final hasRealPressure = stroke.points.any((p) => p.pressure != null);
+  final isHighlighter = stroke.kind == PenStrokeKind.highlighter;
+
+  final pfPoints = stroke.points
+      .map(
+        (p) => pf.Point(
+          p.x * pageSize.width,
+          p.y * pageSize.height,
+          p.pressure ?? 0.5,
+        ),
+      )
+      .toList();
+
+  final outline = pf.getStroke(
+    pfPoints,
+    size: pixelWidth,
+    // Highlighter keeps a constant width (no thinning); pen thins like the
+    // existing ink_canvas (_drawFreehand uses 0.7).
+    thinning: isHighlighter ? 0.0 : 0.7,
+    smoothing: 0.5,
+    streamline: 0.5,
+    // Real stylus pressure → don't simulate; no pressure → let freehand fake
+    // it based on velocity (matches ink_canvas behavior).
+    simulatePressure: !hasRealPressure && !isHighlighter,
+    isComplete: isComplete,
+  );
+
+  final path = Path();
+  if (outline.isEmpty) return path;
+  path.moveTo(outline.first.x, outline.first.y);
+  for (var i = 1; i < outline.length; i++) {
+    path.lineTo(outline[i].x, outline[i].y);
+  }
+  path.close();
+  return path;
+}
+
+/// Paints all committed strokes for the page. Repaints only when the stroke
+/// list identity or page size changes (kept behind a RepaintBoundary).
+class StaticInkPainter extends CustomPainter {
+  StaticInkPainter({required this.strokes, required this.pageSize});
+
+  final List<PenStroke> strokes;
+  final Size pageSize;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    for (final stroke in strokes) {
+      final path = buildStrokePath(stroke, pageSize, isComplete: true);
+      if (path.getBounds().isEmpty) continue;
+      canvas.drawPath(
+        path,
+        Paint()
+          ..color = Color(stroke.color)
+          ..style = PaintingStyle.fill
+          ..isAntiAlias = true,
+      );
+    }
+  }
+
+  @override
+  bool shouldRepaint(StaticInkPainter old) =>
+      !identical(old.strokes, strokes) ||
+      old.strokes.length != strokes.length ||
+      old.pageSize != pageSize;
+}
+
+/// 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 {
+  LiveInkPainter({required this.stroke, required this.pageSize});
+
+  /// Current in-progress stroke, or null when nothing is being drawn.
+  final PenStroke? stroke;
+  final Size pageSize;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final s = stroke;
+    if (s == null || s.points.isEmpty) return;
+    final path = buildStrokePath(s, pageSize, isComplete: false);
+    if (path.getBounds().isEmpty) return;
+    canvas.drawPath(
+      path,
+      Paint()
+        ..color = Color(s.color)
+        ..style = PaintingStyle.fill
+        ..isAntiAlias = true,
+    );
+  }
+
+  @override
+  bool shouldRepaint(LiveInkPainter old) =>
+      !identical(old.stroke, stroke) || old.pageSize != pageSize;
+}