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.

test/shape_geometry_test.dart

@@ -0,0 +1,132 @@
+// test/shape_geometry_test.dart
+//
+// Pins the SHAPE-tool geometry (lib/editor/engine/shape_geometry.dart): each
+// shape is generated as a normalized PenPoint polyline with the documented point
+// counts (line→2, rect→5 closed, ellipse→kEllipseSamples+1), the shapes span the
+// requested start→end box, and translateStroke/translatePoints shift every point
+// without disturbing color/width/kind/brush (the SELECT-tool move primitive).
+
+import 'package:flutter_test/flutter_test.dart';
+
+import 'package:badnote/editor/canvas/editor_tool.dart';
+import 'package:badnote/editor/canvas/pen_stroke.dart';
+import 'package:badnote/editor/engine/brush.dart';
+import 'package:badnote/editor/engine/shape_geometry.dart';
+
+void main() {
+  const a = PenPoint(0.2, 0.3, 1.0);
+  const b = PenPoint(0.8, 0.7, 1.0);
+
+  group('point counts', () {
+    test('line → exactly 2 points (start, end)', () {
+      final pts = generateShapePoints(ShapeKind.line, a, b);
+      expect(pts, hasLength(2));
+      expect(pts.first.x, closeTo(0.2, 1e-9));
+      expect(pts.first.y, closeTo(0.3, 1e-9));
+      expect(pts.last.x, closeTo(0.8, 1e-9));
+      expect(pts.last.y, closeTo(0.7, 1e-9));
+    });
+
+    test('rectangle → 5 points, closed (last == first)', () {
+      final pts = generateShapePoints(ShapeKind.rectangle, a, b);
+      expect(pts, hasLength(5));
+      expect(pts.first.x, closeTo(pts.last.x, 1e-9));
+      expect(pts.first.y, closeTo(pts.last.y, 1e-9));
+      // Axis-aligned box corners spanning the start/end bounds.
+      final xs = pts.map((p) => p.x).toSet();
+      final ys = pts.map((p) => p.y).toSet();
+      expect(xs, containsAll(<double>{0.2, 0.8}));
+      expect(ys, containsAll(<double>{0.3, 0.7}));
+    });
+
+    test('ellipse → kEllipseSamples + 1 points, closed', () {
+      final pts = generateShapePoints(ShapeKind.ellipse, a, b);
+      expect(pts, hasLength(kEllipseSamples + 1));
+      expect(pts.first.x, closeTo(pts.last.x, 1e-9));
+      expect(pts.first.y, closeTo(pts.last.y, 1e-9));
+      // ~48 samples by spec.
+      expect(kEllipseSamples, 48);
+    });
+
+    test('arrow → shaft + 2 head barbs (6 points)', () {
+      final pts = generateShapePoints(ShapeKind.arrow, a, b);
+      // start, end, barb1, back-to-tip, barb2, back-to-tip = 6.
+      expect(pts, hasLength(6));
+      expect(pts[0].x, closeTo(0.2, 1e-9));
+      expect(pts[1].x, closeTo(0.8, 1e-9));
+    });
+
+    test('degenerate arrow (zero length) → just the 2 shaft points', () {
+      final pts = generateShapePoints(ShapeKind.arrow, a, a);
+      expect(pts, hasLength(2));
+    });
+  });
+
+  group('ellipse spans the start→end box', () {
+    test('points stay within the bounding box (inclusive)', () {
+      final pts = generateShapePoints(ShapeKind.ellipse, a, b);
+      for (final p in pts) {
+        expect(p.x, greaterThanOrEqualTo(0.2 - 1e-9));
+        expect(p.x, lessThanOrEqualTo(0.8 + 1e-9));
+        expect(p.y, greaterThanOrEqualTo(0.3 - 1e-9));
+        expect(p.y, lessThanOrEqualTo(0.7 + 1e-9));
+      }
+    });
+  });
+
+  group('translate (SELECT-tool move primitive)', () {
+    test('translatePoints shifts every point, preserves pressure', () {
+      const pts = [PenPoint(0.1, 0.2, 0.5), PenPoint(0.3, 0.4, null)];
+      final moved = translatePoints(pts, 0.05, -0.1);
+      expect(moved[0].x, closeTo(0.15, 1e-9));
+      expect(moved[0].y, closeTo(0.1, 1e-9));
+      expect(moved[0].pressure, 0.5);
+      expect(moved[1].x, closeTo(0.35, 1e-9));
+      expect(moved[1].pressure, isNull);
+    });
+
+    test('translateStroke shifts points and preserves metadata', () {
+      const stroke = PenStroke(
+        points: [PenPoint(0.1, 0.1, 1.0), PenPoint(0.2, 0.2, 1.0)],
+        color: 0xFF112233,
+        width: 0.01,
+        kind: PenStrokeKind.highlighter,
+        brush: BrushKind.pencil,
+      );
+      final moved = translateStroke(stroke, 0.1, 0.2);
+      expect(moved.points[0].x, closeTo(0.2, 1e-9));
+      expect(moved.points[0].y, closeTo(0.3, 1e-9));
+      expect(moved.points[1].x, closeTo(0.3, 1e-9));
+      expect(moved.color, 0xFF112233);
+      expect(moved.width, 0.01);
+      expect(moved.kind, PenStrokeKind.highlighter);
+      expect(moved.brush, BrushKind.pencil);
+    });
+  });
+
+  group('penStrokeBounds', () {
+    test('tight bounds over the points', () {
+      const stroke = PenStroke(
+        points: [PenPoint(0.2, 0.5, 1.0), PenPoint(0.8, 0.1, 1.0)],
+        color: 0xFF000000,
+        width: 0.01,
+        kind: PenStrokeKind.pen,
+      );
+      final bnds = penStrokeBounds(stroke)!;
+      expect(bnds.left, closeTo(0.2, 1e-9));
+      expect(bnds.right, closeTo(0.8, 1e-9));
+      expect(bnds.top, closeTo(0.1, 1e-9));
+      expect(bnds.bottom, closeTo(0.5, 1e-9));
+    });
+
+    test('empty stroke → null bounds', () {
+      const stroke = PenStroke(
+        points: [],
+        color: 0xFF000000,
+        width: 0.01,
+        kind: PenStrokeKind.pen,
+      );
+      expect(penStrokeBounds(stroke), isNull);
+    });
+  });
+}