fix(zoom): drive pinch absolutely from gesture-start snapshot; snappier pen

Zoom flicker root cause (from the on-device badnote_input_log.txt): the pinch
computed its per-frame scale change as desiredScale / getMaxScaleOnAxis(), i.e.
it fed the LIVE matrix back into its own update. Consecutive frames in the log
show `cur` (the live read) dropping to 0.75-0.89 for a single frame while the
result track stayed smooth, so the code demanded a 1.3-1.4x correction that
popped the zoom bigger/smaller and snapped back. The >1.4 glitch guard missed it
because the spikes sat at 1.31-1.40.

Fix: the scale branch of PenInteractiveViewer now drives the transform
ABSOLUTELY from a gesture-start snapshot (_scaleStart, _referenceFocalPoint) plus
the recognizer's clean, monotonic cumulative details.scale. Each frame is fully
re-derived in closed form (pure scale+translate, no matrix inversion, no live
read-back), so a transient mis-read or interleaved write cannot survive into the
next frame. The per-frame glitch guard now keys on the recognizer's own
scale-ratio (the true finger motion) instead of the corrupted live read. 2-finger
pan still falls out of the same focal-anchor formula.

Pen feel: lower perfect_freehand streamline 0.5 -> 0.32 (new shared constants
kPenStreamline/kPenSmoothing, single-sourced across screen + export so the
parity test still holds). At 0.5 a quick flick lagged so far behind the pen that
short fast strokes collapsed toward their start and rendered as a dot
("写字识别成单击"); 0.32 tracks the real path for a crisper, lower-latency feel.

flutter analyze lib/editor clean; 66/66 tests pass (incl. screen==export parity).

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

lib/editor/engine/stroke_geometry.dart

@@ -21,6 +21,17 @@ import 'stroke_model.dart';
 /// Overridable per-stroke via [PenConfig.pressureSensitivity].
 const double kDefaultPenThinning = 0.85;
 
+/// perfect_freehand input-smoothing parameters, shared (single source of truth)
+/// by the on-screen painter and the export path so the two can never diverge
+/// (guarded by the screen==export parity test). [kPenStreamline] lowers the
+/// per-point lag from freehand's 0.5 default to 0.32: at 0.5 a quick flick lags
+/// so far behind the pen that a short fast stroke collapsed toward its start and
+/// rendered as a dot ("写字识别成单击") and the pen felt sluggish; 0.32 tracks the
+/// real path closely (crisper, lower-latency feel) while still damping digitizer
+/// jitter. [kPenSmoothing] keeps freehand's 0.5 corner rounding.
+const double kPenStreamline = 0.32;
+const double kPenSmoothing = 0.5;
+
 /// Builds a closed, fillable outline [Path] for one [stroke], scaled into the
 /// pixel space of [pageSize] (which maps normalized [0,1] coords to pixels).
 ///
@@ -63,8 +74,8 @@ Path buildStrokeOutline(
       // Highlighter keeps a constant width (no thinning); pen uses the
       // configurable [thinning] so Surface-Pen pressure changes width.
       thinning: isHighlighter ? 0.0 : thinning,
-      smoothing: 0.5,
-      streamline: 0.5,
+      smoothing: kPenSmoothing,
+      streamline: kPenStreamline,
       // Real stylus pressure -> don't simulate; no pressure -> let freehand
       // fake it based on velocity (highlighter never simulates). perfect_freehand
       // 2.x honors real pressure when simulatePressure is false.