feat(tools): rnote-style toolbar core writing batch

Replace the ad-hoc tool palette with a shared tool system
(EditorToolKind) across the PDF, note and slide editors, and add
the core writing tools.

- Multiple brushes, each remembering its OWN color (rnote-style):
  selecting a brush restores its color, changing color updates only
  that brush, and each brush button shows its current color.
- Select tool: tap-select a committed stroke, drag to move it,
  delete it — persisted and undoable.
- Shape tool: line / rectangle / ellipse / arrow, drawn with a live
  preview and committed as generated PenStrokes (shape_geometry.dart)
  so they reuse stroke rendering, erase, persistence and undo.
- Highlighter + eraser fold into the same tool system.

Text/bookmark/search+OCR/backgrounds/Windows-Ink are later batches
(TODO). Brush opacity still deferred. analyze clean, 302 tests.

lib/editor/canvas/pen_note_screen.dart

@@ -14,12 +14,14 @@ import '../../models/note.dart';
 import '../../providers/note_provider.dart';
 import '../../providers/ocr_provider.dart';
 import '../engine/brush.dart';
+import '../engine/shape_geometry.dart';
 import '../input/pen_config.dart';
 import '../input/pen_input_service.dart';
 import '../input/pressure_curve.dart' show kNaturalPressureGamma;
 import '../layout/viewport_fit.dart';
 import '../notebook/ink_stroke_adapter.dart';
 import '../ui/pen_settings_page.dart';
+import 'editor_tool.dart';
 import 'pen_canvas.dart';
 import 'pen_palette_widgets.dart';
 import 'pen_stroke.dart';
@@ -45,14 +47,40 @@ class _PenNoteScreenState extends ConsumerState<PenNoteScreen> {
   final List<List<PenStroke>> _undo = [];
   final List<List<PenStroke>> _redo = [];
 
-  CanvasTool _tool = CanvasTool.pen;
+  /// The single active-tool state (shared model across the 3 editors).
+  EditorToolKind _tool = EditorToolKind.brush;
 
-  /// Selected brush for the PEN tool (fountain/ballpoint/pencil). The
+  /// Selected brush for the BRUSH tool (fountain/ballpoint/pencil). The
   /// highlighter tool always uses [BrushKind.highlighter]; local state only for
   /// this increment (not persisted — see TODO(brush-persist-selection)).
   BrushKind _penBrush = BrushKind.fountainPen;
 
-  Color _color = Colors.black;
+  /// Selected shape for the SHAPE tool.
+  ShapeKind _shapeKind = ShapeKind.line;
+
+  /// Index of the currently selected committed stroke (SELECT tool), or null.
+  int? _selectedStroke;
+
+  /// rnote-style per-brush color memory: each brush (and the highlighter)
+  /// remembers its own color. Selecting a brush restores its color; picking a
+  /// color updates ONLY the active brush's entry. In-memory only for this
+  /// increment (TODO(brush-color-persist)).
+  final Map<BrushKind, Color> _brushColors = {
+    BrushKind.fountainPen: Colors.black,
+    BrushKind.ballpoint: Colors.blue,
+    BrushKind.pencil: Colors.green,
+    BrushKind.highlighter: Colors.orange,
+  };
+
+  /// The brush whose color the color-dots edit: the highlighter when the
+  /// highlighter tool is active, otherwise the selected pen brush.
+  BrushKind get _activeColorBrush => _tool == EditorToolKind.highlighter
+      ? BrushKind.highlighter
+      : _penBrush;
+
+  /// The active drawing color (the active brush's remembered color).
+  Color get _color => _brushColors[_activeColorBrush] ?? Colors.black;
+
   bool _allowFingerDrawing = false;
   bool _dirty = false;
   bool _needsCenter = true;
@@ -242,10 +270,46 @@ class _PenNoteScreenState extends ConsumerState<PenNoteScreen> {
     _transform.value = Matrix4.identity()..translateByDouble(o.dx, o.dy, 0, 1);
   }
 
-  double get _strokeWidth => _tool == CanvasTool.highlighter
+  double get _strokeWidth => _tool == EditorToolKind.highlighter
       ? (_penConfig?.value.highlighterWidth ?? _highlighterWidthFraction)
       : (_penConfig?.value.penWidth ?? _penWidthFraction);
 
+  // ── SELECT tool: select / move / delete (reuses the undo stacks) ─────────────
+
+  /// Set (or clear) the selected stroke from a SELECT-tool tap.
+  void _selectStroke(int? index) {
+    setState(() => _selectedStroke = index);
+  }
+
+  /// Translate the selected stroke by ([dx],[dy]) normalized. On the first delta
+  /// of a drag ([isDragStart]) push ONE undo snapshot so the whole drag is a
+  /// single undo step.
+  void _moveStroke(int index, double dx, double dy, bool isDragStart) {
+    if (index < 0 || index >= _strokes.length) return;
+    setState(() {
+      if (isDragStart) _pushUndo();
+      final next = List<PenStroke>.from(_strokes);
+      next[index] = translateStroke(next[index], dx, dy);
+      _strokes = next;
+      _dirty = true;
+    });
+  }
+
+  /// Delete the selected stroke (button or long-press), as one undo step.
+  void _deleteSelected() {
+    final idx = _selectedStroke;
+    if (idx == null || idx < 0 || idx >= _strokes.length) return;
+    setState(() {
+      _pushUndo();
+      _strokes = [
+        ..._strokes.sublist(0, idx),
+        ..._strokes.sublist(idx + 1),
+      ];
+      _selectedStroke = null;
+      _dirty = true;
+    });
+  }
+
   @override
   Widget build(BuildContext context) {
     final cs = Theme.of(context).colorScheme;
@@ -324,10 +388,14 @@ class _PenNoteScreenState extends ConsumerState<PenNoteScreen> {
           pageSize: pageSize,
           strokes: _strokes,
           transformationController: _transform,
-          tool: _tool,
+          tool: editorToolToCanvas(_tool),
           brush: _penBrush,
+          shapeKind: _shapeKind,
           color: _color,
           strokeWidth: _strokeWidth,
+          selectedStrokeIndex: _selectedStroke,
+          onSelectStroke: _selectStroke,
+          onMoveStroke: _moveStroke,
           pressureGamma:
               _penConfig?.value.pressureGamma ?? kNaturalPressureGamma,
           eraserRadius: _penConfig?.value.eraserRadius ?? kDefaultEraserRadius,
@@ -367,30 +435,57 @@ class _PenNoteScreenState extends ConsumerState<PenNoteScreen> {
         child: Row(
           mainAxisSize: MainAxisSize.min,
           children: [
-            // Pen tool with brush picker (fountain / ballpoint / pencil).
+            // Pen tool with brush picker (fountain / ballpoint / pencil), each
+            // brush showing its own remembered color.
             BrushPickerButton(
               selected: _penBrush,
-              active: _tool == CanvasTool.pen,
+              active: _tool == EditorToolKind.brush,
               tooltip: 'Brush',
               labelFor: brushLabelEn,
+              colorFor: (b) => _brushColors[b] ?? Colors.black,
               onSelected: (b) => setState(() {
                 _penBrush = b;
-                _tool = CanvasTool.pen;
+                _tool = EditorToolKind.brush;
               }),
             ),
             ToolButton(
               icon: Icons.brush_outlined,
-              selected: _tool == CanvasTool.highlighter,
+              selected: _tool == EditorToolKind.highlighter,
               tooltip: 'Highlighter',
               onPressed: () =>
-                  setState(() => _tool = CanvasTool.highlighter),
+                  setState(() => _tool = EditorToolKind.highlighter),
             ),
             ToolButton(
               icon: Icons.cleaning_services_outlined,
-              selected: _tool == CanvasTool.eraser,
+              selected: _tool == EditorToolKind.eraser,
               tooltip: 'Eraser',
-              onPressed: () => setState(() => _tool = CanvasTool.eraser),
+              onPressed: () => setState(() => _tool = EditorToolKind.eraser),
             ),
+            // Select (cursor) + shape tools.
+            ToolButton(
+              icon: Icons.ads_click,
+              selected: _tool == EditorToolKind.select,
+              tooltip: 'Select',
+              onPressed: () => setState(() => _tool = EditorToolKind.select),
+            ),
+            ShapePickerButton(
+              selected: _shapeKind,
+              active: _tool == EditorToolKind.shape,
+              tooltip: 'Shape',
+              labelFor: shapeLabelEn,
+              onActivate: () => setState(() => _tool = EditorToolKind.shape),
+              onSelected: (s) => setState(() {
+                _shapeKind = s;
+                _tool = EditorToolKind.shape;
+              }),
+            ),
+            if (_tool == EditorToolKind.select && _selectedStroke != null)
+              ToolButton(
+                icon: Icons.delete_outline,
+                selected: false,
+                tooltip: 'Delete selection',
+                onPressed: _deleteSelected,
+              ),
             PaletteDivider(cs: cs),
             ToolButton(
               icon: Icons.undo,
@@ -430,12 +525,18 @@ class _PenNoteScreenState extends ConsumerState<PenNoteScreen> {
   }
 
   Widget _colorDot(Color c, ColorScheme cs) {
+    // Selected against the ACTIVE brush's remembered color. A color tap updates
+    // only that brush's entry (rnote per-brush color memory).
     final selected = _color.toARGB32() == c.toARGB32() &&
-        _tool != CanvasTool.eraser;
+        _tool != EditorToolKind.eraser &&
+        _tool != EditorToolKind.select;
     return GestureDetector(
       onTap: () => setState(() {
-        _color = c;
-        if (_tool == CanvasTool.eraser) _tool = CanvasTool.pen;
+        if (_tool == EditorToolKind.eraser ||
+            _tool == EditorToolKind.select) {
+          _tool = EditorToolKind.brush;
+        }
+        _brushColors[_activeColorBrush] = c;
       }),
       child: AnimatedContainer(
         duration: const Duration(milliseconds: 150),