Give a panorama a wide cell in the grid

A 4:1 composite drawn in one square cell is a strip a few pixels high.
A photograph about twice as wide as it is tall (1.9 and up) now spans
two columns, three from 2.9, with a thumbnail class of its own whose
long edge is sized for that width; on the tablet, or where the columns
are too few to put it beside anything, it takes the whole row.

Rows are computed in one place, library_ui::layout. The grid is a
lattice of slots: each cell is drawn at the slot Rust gives it, and a
wide cell that would not fit in what is left of a row starts the next
one, leaving the gap empty so the grid still reads in capture order.
The scrollbar spans the slots, a scroll reports a slot that the layout
turns back into an ordinal, and scrubs, restores and the cursor go
through the same conversion. Up and down step by rows through the
layout rather than by a row's worth of ordinals; left and right, a
shift-click's run, burst folding and the timeline are ordinal-based
and unchanged.

The window's own read carries each photograph's w and h, so the cells
know their shape with no query per cell. Where the wide ones sit in
the whole list is one query, run when what the grid lists changes or
when a window finds the layout out of date, and a library with no
panorama answers it from a partial index created on first use
(images_wide), not a schema bump. The merge makes the wide thumbnail
for a wide composite along with the others.

core/dr-thumbs/src/lib.rs

@@ -72,6 +72,13 @@ pub enum ThumbSize {
     /// Zoomed cells, the loupe, and the filmstrip. ~45 KB each, fetched only
     /// where something actually asks for that detail.
     Large = 1,
+    /// TRACES: FR-MRG-6
+    /// A panorama's cell, which spans two or three columns — or the whole
+    /// row on the tablet — at the height of one. Its long edge is sized for
+    /// that width rather than for a square: the grid class of a 4:1
+    /// panorama is 256×64, a smear across three cells. Made only for
+    /// photographs that wide, so it costs a library nothing else.
+    Wide = 2,
 }
 
 impl ThumbSize {
@@ -80,6 +87,18 @@ impl ThumbSize {
         match self {
             ThumbSize::Grid => 256,
             ThumbSize::Large => 1024,
+            ThumbSize::Wide => 2048,
+        }
+    }
+
+    /// The class for a cell `span` columns wide whose columns are drawn at
+    /// `pixels`: the wide class for any cell wider than one, whatever the
+    /// zoom, since its height is a column's and its width is not.
+    pub fn for_span(span: usize, pixels: u32) -> Self {
+        if span > 1 {
+            ThumbSize::Wide
+        } else {
+            Self::for_cell(pixels)
         }
     }
 
@@ -102,15 +121,13 @@ impl ThumbSize {
         match v {
             0 => Some(ThumbSize::Grid),
             1 => Some(ThumbSize::Large),
+            2 => Some(ThumbSize::Wide),
             _ => None,
         }
     }
 
     fn from_i64(v: i64) -> Self {
-        match v {
-            1 => ThumbSize::Large,
-            _ => ThumbSize::Grid,
-        }
+        Self::from_stored(v).unwrap_or(ThumbSize::Grid)
     }
 }