fix(render): map the visible range through the series' own x

Renderer::draw_traces picked the sample window with (x - x0()) / dx(), and dx() is
documented as a *nominal* spacing -- for a series whose x is a streamed timestamp it
is only the mean of the retained window. The window it computed therefore landed
inside the visible range, and the two end segments, the ones that enter and leave the
frame, were never emitted: the left and right margins of a zoomed-in view came out
empty. A wide enough drift dropped the trace entirely (last <= first).

It asks Series::neighbours() now -- a binary search over the real x, the same call the
crosshair reads through, costing the same. A uniform series answers the same question
through the same call, so it is one path. dx is still read for the samples-per-pixel
density estimate, where a nominal spacing is exactly right.

Test: a_sparse_window_between_samples_still_inks_both_margins -- a series whose dx()
lies, with the window strictly between two samples, so nothing inside the window is
sampled and only the crossing segments can ink it. With the grid walk reverted it
stages nothing at all (visible=0, gathered=0, covered=0/24); with the fix it stages the
three bracketing samples and covers 24/24 columns.

src/render/renderer.cpp

@@ -42,15 +42,6 @@ bool fail(Status* st, ErrorCode code, const char* message) noexcept {
 /// clamp, so it lands off-scale rather than as NaN.
 f64 space(f64 v, bool log) noexcept { return log ? Transform::log10_positive(v) : v; }
 
-/// Sample index for a (possibly fractional, possibly non-finite) position in a
-/// series' index space, clamped to [0, n]: NaN and -inf to 0, +inf to n, so a
-/// range the axis cannot map still yields a valid window.
-u64 clamp_index(f64 v, u64 n) noexcept {
-  if (!(v > 0.0)) return 0;
-  if (v >= static_cast<f64>(n)) return n;
-  return static_cast<u64>(v);
-}
-
 /// One ASCII/UTF-8 line of the measurement readout. `format_si` leaves room for
 /// three significant digits plus a prefix and sign.
 constexpr usize kNumberChars = 24;
@@ -994,15 +985,26 @@ void Renderer::draw_traces(const Plot& plot, const PlotLayout& layout) {
     const u64 n = series.size();
     if (!(dx > 0.0) || n == 0) continue;
 
-    // Map the visible x range onto sample indices. One sample of slack on each
-    // side covers a partially visible end bucket; the range is clamped to the
-    // series, so a zoomed-out view never asks for more than exists.
+    // The visible x range onto sample indices, through the series' *own* x.
+    //
+    // Not the `(x - x0()) / dx()` grid: `dx()` is documented as a nominal spacing (the LOD
+    // level, a coarse snap) and for a series whose x is a streamed timestamp it is only the
+    // mean of the retained window. Walking that grid lands the window inside the visible range
+    // -- and the first and last *segments*, the ones that enter and leave the frame, are then
+    // not drawn at all, which is the empty margin at both edges of a zoomed-in view. A series
+    // with a uniform x answers the same question through the same call, so this is the one
+    // path. One sample of slack on each side keeps a partially visible end bucket whole, and
+    // the result is clamped to the series: a zoomed-out view never asks for more than exists,
+    // and a window that reaches past the data leaves the margin genuinely -- correctly -- empty.
     const Range x_range = plot.x_range(trace.axis_x);
-    f64 lo = (x_range.min - series.x0()) / dx;
-    f64 hi = (x_range.max - series.x0()) / dx;
-    if (hi < lo) std::swap(lo, hi);
-    const u64 first = clamp_index(std::floor(lo) - 1.0, n);
-    const u64 last = clamp_index(std::ceil(hi) + 1.0, n);
+    // `dx` is still read above for the samples-per-pixel estimate -- a density, where a nominal
+    // spacing is exactly right -- and never for the window itself.
+    u64 first = 0;
+    u64 last = n;
+    u64 i0 = 0;
+    u64 i1 = 0;
+    if (series.neighbours(x_range.min, i0, i1)) first = i0 > 0 ? i0 - 1 : 0;
+    if (series.neighbours(x_range.max, i0, i1)) last = std::min(n, i1 + 1);
     if (last <= first) continue;
 
     // This is the whole performance contract: the window, never the series.