Drag the date range on the axis it is chosen from

The range could be turned on with a finger and not aimed with one. Its two
ends were typed as `YYYY-MM-DD` into 108px fields behind a soft keyboard, to
name days already drawn on the axis a thumb away; and the chip that seeds them
takes its span from the timeline's zoom and pan, which are a wheel and a middle
button. A touch screen has neither, so on Android the filter was a switch with
no aim.

The band is now on the timeline. Two ends with grips, dragged along the bars,
released to filter — the histogram was already how a period is found, and this
makes it how a period is stated. Both ends snap to whole days, which is what
the typed fields mean, what `show_range` reads back out, and a floor under a
range dragged shut. The fields stay for what dragging cannot do: name an exact
day, and say in words what the range is.

For that to work the axis had to stop following the range. Redrawn to the band,
it moved the ground under the very handles doing the narrowing, and there was
nothing outside the range left to widen back into.

While there: a fixed number of equal bins instead of calendar buckets. Between
one calendar unit and the next the bar count is free to wander by a factor of
twelve, so zooming in halved it two steps out of three — the same picture drawn
wider until it jumped back to fine. Equal bins also include the empty ones, so
a bar's position on the track and the date under it are finally the same
quantity; before, a library with gaps drew a February six months wide and the
marker, the band and a click all pointed somewhere else. The count is a
setting, 32 or 64, because the right answer is a question about the screen.

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

core/dr-catalog/src/lib.rs

@@ -134,6 +134,19 @@ impl Granularity {
     /// about 48 months — and on a linear measure the larger count always looks
     /// further away, which would bias every choice towards too few bars.
     pub fn for_span(seconds: i64) -> Self {
+        Self::for_bucket(seconds.max(1) / Self::TARGET_BARS)
+    }
+
+    /// The calendar unit nearest a bucket of `seconds`, for *labelling* one.
+    ///
+    /// Split out from [`Self::for_span`] because the axis no longer buckets by
+    /// calendar unit at all — it divides the visible span into a fixed number
+    /// of equal bins (see `LibrarySettings::timeline_bars`). What is still
+    /// wanted is the unit a bin is closest to, so a bin of about a day is
+    /// labelled as a date and one of about a year as a year. Asked directly
+    /// rather than derived from the span, because the bin count is now the
+    /// user's rather than this module's target.
+    pub fn for_bucket(seconds: i64) -> Self {
         let seconds = seconds.max(1) as f64;
         // Finest first, so that when two options are equally far from the
         // target the finer one wins: `min_by` keeps the first minimum it saw,
@@ -147,15 +160,14 @@ impl Granularity {
         .into_iter()
         .min_by(|a, b| {
             let cost = |g: Granularity| {
-                let bars = seconds / g.approx_seconds() as f64;
-                // How far off the target, measured multiplicatively: twice as
-                // many and half as many are equally wrong.
+                // How far off, measured multiplicatively: twice as long and
+                // half as long are equally wrong.
                 //
-                // Deliberately not clamped to at least one bar. A span shorter
-                // than a bucket scores *worse* the coarser the bucket, which is
-                // what makes an hour of photographs pick hourly bars instead of
-                // every option tying at "one bar" and the coarsest winning.
-                (bars / Self::TARGET_BARS as f64).ln().abs()
+                // Deliberately not clamped. A bucket shorter than the unit
+                // scores *worse* the coarser the unit, which is what makes an
+                // hour of photographs pick hourly bars instead of every option
+                // tying at "one bucket" and the coarsest winning.
+                (seconds / g.approx_seconds() as f64).ln().abs()
             };
             cost(*a)
                 .partial_cmp(&cost(*b))