feat(p0): live canvas renders via revision-gated ui.Picture cache (step 3)

The live PenCanvas committed-ink layer now uses the relocated render/ painters
(render.StaticInkPainter + InkPictureCache + StrokeStore) instead of the old
canvas/ink_painters versions — the P0.5 perf prerequisite. The committed layer's
ui.Picture is recorded once per StrokeStore.revision and replayed on the raster
thread, so pinch / pan / live-stroke frames no longer re-rasterize committed ink.

- pen_canvas mirrors widget.strokes (PenStroke) into a StrokeStore (EditorStroke)
  on every new-list identity (the parent already replaces the list on each
  commit/erase), bumping the revision → cache invalidates → static layer repaints.
- thinning (PenConfig.pressureSensitivity) is threaded into the render painters
  AND folded into the cache key + shouldRepaint, so a sensitivity change can't
  replay a stale Picture built at the old thinning.
- live layer converts _liveStroke→EditorStroke per frame (correct: it must
  repaint every move); eraser preview keeps the existing canvas painter.
- pen_canvas disposes the InkPictureCache.

Equivalent by construction (both paths call buildStrokeOutline with the same
thinning); device confirms final fidelity. The old canvas Static/LiveInkPainter
are now orphaned (buildStrokePath still used by tests) — P1 deletes them.

flutter analyze lib/editor clean; 90/90 tests (+6: thinning repaint/cache + live).

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

lib/editor/render/live_ink_painter.dart

@@ -18,18 +18,25 @@ class LiveInkPainter extends CustomPainter {
   const LiveInkPainter({
     required this.live,
     required this.pageSize,
+    this.thinning = kDefaultPenThinning,
   });
 
   /// The stroke currently being drawn, or null when idle.
   final EditorStroke? live;
   final Size pageSize;
 
+  /// perfect_freehand pressure→width response (from `PenConfig.pressureSensitivity`),
+  /// kept consistent with the static layer so the stroke doesn't change width
+  /// the instant it commits.
+  final double thinning;
+
   @override
   void paint(Canvas canvas, Size size) {
     final stroke = live;
     if (stroke == null || stroke.points.isEmpty) return;
 
-    final path = buildStrokeOutline(stroke, pageSize, isComplete: false);
+    final path = buildStrokeOutline(stroke, pageSize,
+        isComplete: false, thinning: thinning);
     if (path.getBounds().isEmpty) return;
 
     canvas.drawPath(
@@ -43,5 +50,7 @@ class LiveInkPainter extends CustomPainter {
 
   @override
   bool shouldRepaint(LiveInkPainter old) =>
-      !identical(old.live, live) || old.pageSize != pageSize;
+      !identical(old.live, live) ||
+      old.pageSize != pageSize ||
+      old.thinning != thinning;
 }

lib/editor/render/static_ink_painter.dart

@@ -28,6 +28,7 @@ class StaticInkPainter extends CustomPainter {
     required this.store,
     required this.pageSize,
     required this.cache,
+    this.thinning = kDefaultPenThinning,
   }) : revision = store.revision;
 
   final String hostId;
@@ -35,6 +36,11 @@ class StaticInkPainter extends CustomPainter {
   final Size pageSize;
   final InkPictureCache cache;
 
+  /// perfect_freehand pressure→width response (from `PenConfig.pressureSensitivity`).
+  /// Folded into the cache key + [shouldRepaint] so a sensitivity change can't
+  /// replay a stale Picture built at the old thinning.
+  final double thinning;
+
   /// Revision snapshot captured at construction time. Used by [shouldRepaint]
   /// so two painters built at different revisions compare correctly even when
   /// they share the same [StrokeStore] instance.
@@ -42,12 +48,15 @@ class StaticInkPainter extends CustomPainter {
 
   @override
   void paint(Canvas canvas, Size size) {
-    final picture = cache.getOrBuild(hostId, store.revision, pageSize, () {
+    // thinning is part of the cache identity (different thinning ⇒ different
+    // outline) so it MUST be in the key, not just shouldRepaint.
+    final cacheKey = '$hostId#${thinning.toStringAsFixed(4)}';
+    final picture = cache.getOrBuild(cacheKey, store.revision, pageSize, () {
       final recorder = ui.PictureRecorder();
       final rec = Canvas(recorder);
       for (final stroke in store.committed) {
-        final path =
-            buildStrokeOutline(stroke, pageSize, isComplete: true);
+        final path = buildStrokeOutline(stroke, pageSize,
+            isComplete: true, thinning: thinning);
         if (path.getBounds().isEmpty) continue;
         rec.drawPath(
           path,
@@ -65,5 +74,7 @@ class StaticInkPainter extends CustomPainter {
 
   @override
   bool shouldRepaint(StaticInkPainter old) =>
-      old.revision != store.revision || old.pageSize != pageSize;
+      old.revision != store.revision ||
+      old.pageSize != pageSize ||
+      old.thinning != thinning;
 }