fix(data): the gather origin is the caller's, so a deep zoom draws on the sample

`Series::gather()` stages x as f32 relative to `x0()` -- the start of the
*retained window* -- so the value's ULP was a fraction of data the view need
not even hold: 1.9 us over a 20 s ring. A readout quotes `x_at()` in exact
f64, so at a 10 us view across 700 px that put more than a hundred pixels
between where a sample is drawn and the x reported for it.

The origin is now a parameter, placed before `out_xy` so every call site is a
type error rather than a silent change of behaviour. `Renderer::draw_traces`
passes the visible range's minimum, which makes the error a fixed 2^-24 of the
span on screen -- 4e-5 of a pixel over a 700 px axis -- at every zoom.

`stage_xy()` loses its second origin as a consequence: the gather origin and
the draw origin are now always the same value, so the linear case hands the
gathered buffer straight to `add_polyline_xy()` with no per-point copy.

`Plot::crosshair_point()` names the query itself, the one origin that cannot
lose precision for a caller that might.

Guarded by `a_gather_origin_at_the_view_keeps_a_deep_zoom_on_the_sample_it_quotes`,
which measures the error in pixels both ways: under 0.05 px with the view's
minimum, over 10 px with `x0()`.

src/plot/plot.cpp

@@ -1464,7 +1464,10 @@ bool Plot::crosshair_point(u32 trace, f64 x, f64& out_x, f64& out_y) const {
   // when it fell between them. The scratch is cleared and refilled rather than reallocated,
   // and sized for two pairs from construction, so the pointer path allocates nothing.
   crosshair_scratch_.clear();
-  series->gather(0u, span.begin, span.end + 1u, crosshair_scratch_);
+  // The origin is the query itself: only y is read out of the pairs below -- the x comes back
+  // through `x_at()` -- so this names the one origin that cannot lose precision for a caller
+  // that might.
+  series->gather(0u, span.begin, span.end + 1u, x, crosshair_scratch_);
   const usize pairs = static_cast<usize>(span.end - span.begin + 1u);
   if (crosshair_scratch_.size() != 2u * pairs) return false;  // a series that produced nothing
   const f64 y_begin = static_cast<f64>(crosshair_scratch_[1u]);
@@ -1480,9 +1483,9 @@ bool Plot::crosshair_point(u32 trace, f64 x, f64& out_x, f64& out_y) const {
   // `NearestSample`: the nearer of the two, and **its own x with it**. `span.t` is measured on
   // the samples' own coordinates, so "nearer" is exact on any grid; a tie reads the earlier
   // sample, which is the bias `crosshair_span()` already takes for a degenerate pair. The x
-  // comes back through `x_at()` rather than from the gathered pairs, which are relative to
-  // `x0()` by the `Series::gather()` contract -- adding it back here would be a second
-  // reconstruction of a coordinate the series will hand over directly.
+  // comes back through `x_at()` rather than from the gathered pairs, which are relative to a
+  // caller-named origin by the `Series::gather()` contract -- adding it back here would be a
+  // second reconstruction of a coordinate the series will hand over directly.
   const bool take_begin = span.t <= 0.5;
   out_x = series->x_at(take_begin ? span.begin : span.end);
   out_y = take_begin ? y_begin : y_end;