feat(plot)!: harden pipeline, XY series, dash/markers, touch, packaging

Breaking: Series::gather emits x relative to x0() and takes a GatherMode;
consumers reconstruct absolute x in f64 before mapping (series.hpp documents
the contract).

Bugs, each pinned by a fail-before regression test:
- render: f32 staging quantised epoch-time x into 128 px columns; every
  data-space draw now stages to_space(x) - to_space(origin) with the origin
  folded into the offset uniform in f64 (epoch/zero-origin twins rasterise
  identically)
- ticks: major test was ULP-fragile and blanked epoch axes; majors are an
  integer-index test and are never truncated by the minor cap
- gather: LOD envelope emitted buckets straddling [begin,end); ceil/floor
  bucket edges + raw lead/trail spans
- live follow: log x axes held a linear span and zoomed every frame; span and
  offset now live in axis space (plot + both figure link-group paths)
- input: a zero-notch wheel disarmed auto_scale on every axis; dy==0 pans x,
  factor == 1 / inf refused in wheel and drag zoom
- render: the single text flush painted legend names over the crosshair
  readout panel; two batches, under flushed before the panel
- data: NaN dropped from min/max unless it seeded the fold; non-finite
  samples are now excluded from every aggregate and from cached bounds

Robustness: viewport normalisation (no clamp UB), non-finite range refusal,
pyramid level cap at 57 (no shift/div UB through public gather), rounded ring
capacity documented + pre-sized, GL blend func and UNPACK_ALIGNMENT
save/restore, Renderer::release_gl() teardown, u64 buffer epochs, annotation
captions clamped, button-aware GLFW row capture, cached figure row rects (no
per-event layout), ruler-pair measurement refused, span-nonfinite guards in
axis_ends.

Features: XY series (sorted x, binary-search neighbours/snap, LOD over sample
index); StreamSeries::freeze(); ArraySeries::push(); per-trace dash and
markers (scatter at width 0) with auto or literal stride; GatherMode
Envelope/Nearest/Mean via bucket_sum/sumsq; Style::line_aa_px; per-glyph text
colour (readout values in trace colour); wheel-dx x pan; arrow-key pan;
Escape cancels a drag and restores captured ranges; modifier-masked box zoom
(Shift both, Ctrl x, Alt y); double-click reset via PointerEvent::time_s;
ImGui key repeat unified; pinch gestures on Qt and GTK; pixelDelta wheel path
and DevicePixelRatioChange handling; GNUInstallDirs, SOVERSION,
SameMinorVersion, generated plot/version.hpp, relocatable plot.pc, licence
install, FILES_MATCHING, GitHub Actions CI (debug/coverage/asan).

Suite 283 -> 350 cases, 0 failed; coverage 93.9% (3730/3971) over 24 files,
floor 80/90 held; ASAN preset suite green; all four demos run headless (the
GTK scripted-resize check needs a window manager and fails identically on the
parent commit); readme_main.cpp committed and compiles with the README
command; pkg-config and find_package consumption verified from a relocated
install prefix.

tests/test_qt_pointer.cpp

@@ -57,3 +57,93 @@ PLOT_TEST(pointer_anchor_reports_no_movement_before_its_first_sample) {
   PLOT_CHECK_NEAR(delta.x, 0.0, 1e-9);
   PLOT_CHECK_NEAR(delta.y, 0.0, 1e-9);
 }
+
+// --- the pinch --------------------------------------------------------------
+
+// Qt reports a pinch as cumulative numbers -- `totalScaleFactor()` since the
+// gesture began, `centerPoint()` where the fingers are now -- while the
+// controller's `GestureEvent` wants the increments: this frame's zoom factor
+// (1.0 = no change) and the focal point's movement since the previous event.
+// `PinchTracker` is the fold, and the ratios it produces are what a pinch feels
+// like through: a cumulative 1.0 -> 1.25 -> 1.5 spread is a 1.25 frame followed
+// by a 1.2 frame, never a 1.25 then a 1.5 (which would zoom twice as far as the
+// fingers did).
+PLOT_TEST(pinch_tracker_folds_cumulative_scale_into_incremental_zoom) {
+  plot::qt::PinchTracker pinch;
+
+  // The begin anchors the fold and zooms nothing: a pinch that just started has
+  // moved no scale yet, so the first event the controller could see is 1.0.
+  pinch.begin(1.0f, {200.0f, 150.0f});
+  PLOT_CHECK(pinch.active);
+  const plot::input::GestureEvent started = pinch.update(1.0f, {200.0f, 150.0f}, 1.0);
+  PLOT_CHECK_NEAR(started.scale, 1.0, 1e-6);
+  PLOT_CHECK_NEAR(started.dx, 0.0, 1e-6);
+  PLOT_CHECK_NEAR(started.dy, 0.0, 1e-6);
+
+  // Fingers spread to 1.25 cumulative, focal steady: one 1.25 zoom about the
+  // focal point, and no pan.
+  const plot::input::GestureEvent spread = pinch.update(1.25f, {200.0f, 150.0f}, 1.0);
+  PLOT_CHECK_NEAR(spread.scale, 1.25, 1e-6);
+  PLOT_CHECK_NEAR(spread.dx, 0.0, 1e-6);
+  PLOT_CHECK_NEAR(spread.dy, 0.0, 1e-6);
+
+  // Spread on to 1.5: the *increment* is 1.5 / 1.25, not 1.5 again.
+  const plot::input::GestureEvent more = pinch.update(1.5f, {200.0f, 150.0f}, 1.0);
+  PLOT_CHECK_NEAR(more.scale, 1.2, 1e-6);
+
+  // And a pinch in (0.75 of the cumulative): an incremental shrink.
+  const plot::input::GestureEvent pinch_in = pinch.update(0.75f, {200.0f, 150.0f}, 1.0);
+  PLOT_CHECK_NEAR(pinch_in.scale, 0.5, 1e-6);
+}
+
+// The focal point's movement is the two-finger pan, and it is mapped through the
+// ratio in force *now* from an anchor kept in **logical** pixels -- the same
+// convention as PointerAnchor above, because the same defect applies: a pinch
+// that crosses onto a display with another scale factor must not read the ratio
+// change as a focal jump (which the controller would apply as a pan).
+PLOT_TEST(pinch_tracker_maps_focal_movement_through_the_current_dpr) {
+  plot::qt::PinchTracker pinch;
+  pinch.begin(1.0f, {200.0f, 150.0f});
+
+  // A plain pan at 1.0: ten logical pixels right, no zoom.
+  const plot::input::GestureEvent moved = pinch.update(1.0f, {210.0f, 150.0f}, 1.0);
+  PLOT_CHECK_NEAR(moved.scale, 1.0, 1e-6);
+  PLOT_CHECK_NEAR(moved.dx, 10.0, 1e-6);
+  PLOT_CHECK_NEAR(moved.dy, 0.0, 1e-6);
+  PLOT_CHECK_NEAR(moved.x, 210.0, 1e-6);  // the focal point the zoom anchors on
+
+  // Mid-pinch the window lands on the 1.25 display. The fingers move 4 more
+  // logical pixels: the movement is 4 * 1.25 = 5 device pixels, and the anchor
+  // the next frame is measured from is the new logical point -- not the old one
+  // rescaled, which would read the ratio change itself as a jump.
+  const plot::input::GestureEvent rescaled = pinch.update(1.0f, {214.0f, 150.0f}, 1.25);
+  PLOT_CHECK_NEAR(rescaled.scale, 1.0, 1e-6);
+  PLOT_CHECK_NEAR(rescaled.dx, 5.0, 1e-6);
+  PLOT_CHECK_NEAR(rescaled.dy, 0.0, 1e-6);
+  PLOT_CHECK_NEAR(rescaled.x, 214.0 * 1.25, 1e-6);
+  PLOT_CHECK_NEAR(rescaled.y, 150.0 * 1.25, 1e-6);
+
+  // A diagonal movement, both axes mapped.
+  const plot::input::GestureEvent diagonal = pinch.update(1.0f, {214.0f, 154.0f}, 1.25);
+  PLOT_CHECK_NEAR(diagonal.dx, 0.0, 1e-6);
+  PLOT_CHECK_NEAR(diagonal.dy, 5.0, 1e-6);
+}
+
+// An update outside a gesture -- before any begin, or after the end/cancel --
+// zooms and moves nothing: a host that missed the start (or a straggler event
+// Qt delivers out of order) must not zoom from a made-up anchor.
+PLOT_TEST(pinch_tracker_ignores_updates_outside_a_gesture) {
+  plot::qt::PinchTracker pinch;
+  const plot::input::GestureEvent orphan = pinch.update(2.0f, {10.0f, 10.0f}, 1.0);
+  PLOT_CHECK_NEAR(orphan.scale, 1.0, 1e-9);
+  PLOT_CHECK_NEAR(orphan.dx, 0.0, 1e-9);
+  PLOT_CHECK_NEAR(orphan.dy, 0.0, 1e-9);
+
+  pinch.begin(1.0f, {0.0f, 0.0f});
+  pinch.end();
+  PLOT_CHECK(!pinch.active);
+  const plot::input::GestureEvent straggler = pinch.update(2.0f, {10.0f, 10.0f}, 1.0);
+  PLOT_CHECK_NEAR(straggler.scale, 1.0, 1e-9);
+  PLOT_CHECK_NEAR(straggler.dx, 0.0, 1e-9);
+  PLOT_CHECK_NEAR(straggler.dy, 0.0, 1e-9);
+}