Make the People screen a place work can be done

Five faults, all on one screen, and the Slint and Rust halves of each have to
land together.

**Regroup froze the window.** It ran inside the Slint callback, on the UI
thread. It is much faster now, but fast is not bounded — the work grows with the
library, and the one thing that must not grow with the library is how long the
window stops answering. It runs on a worker thread with an mpsc channel and a
250ms poll, like every other long pass in this module, and the button says what
it is doing instead of the window going quiet. Cancellation is dropping the
receiver. Reclustering also prunes the empty groups the previous pass left, so
pressing the button twice no longer fills the rail with "Unnamed (0 faces)".

**The faces were a single row running off the screen.** The comment on the
layout claimed to be a wrapping row; Slint has no flow layout and a
HorizontalLayout does not wrap, so a person with forty faces was a person whose
faces could not be reviewed past the fifth. It is now laid out the way the
library grid lays out thumbnails, with the same arithmetic: choose how many
columns of roughly the requested size fit, then divide the width between them so
the cells fill the row exactly and nothing overhangs.

**The header did not fit a phone.** A 240px name field beside five buttons is
wider than an Android screen — and worse than not fitting, a layout cannot be
narrower than its children's minimums, so the row reported that oversized
minimum upwards and inflated the whole screen. The faces grid is its sibling, so
it would have been measured against a width that was never on the display. The
header is now two rows, the actions sit in a Flickable that scrolls rather than
overflowing, and the rail narrows to 132px on the compact class.

**Strangers crowded out the people who matter.** Most clusters in a real library
are passers-by and other people's guests. "Not interested" sets a group aside;
the rail hides it and says how many are hidden, with one button to bring them
back. Reversible, and never a deletion — see the catalog commit for why.

**A face was a dead end.** Identifying someone and then having no way to see
their photographs is a filing cabinet with no drawer handles. "Show photos"
narrows the library grid to that person and leaves a chip on the filter bar
saying so, which is also how it is cleared. It is a term on `RatingFilter`
rather than a grid scope of its own, exactly as that struct's own doc says new
narrowing terms should be — so the count and the cells are narrowed by the same
thing, and it composes with the others for free. Suggested faces count, not only
confirmed ones, or a freshly grouped person would show an empty grid.

Crops are read from where they are now stored, falling back to cutting one out
of the proxy for faces indexed before that existed.

480 tests pass.

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

ui/dr-ui/src/library_ui.rs

@@ -5046,6 +5046,55 @@ pub fn wire<F>(
         });
     }
 
+    {
+        let weak = window.as_weak();
+        let ctl = ctl.clone();
+        window.on_identity_show_photos(move |id| {
+            let Some(w) = weak.upgrade() else { return };
+            let person = dr_catalog::faces::PersonId(id.max(0) as u64);
+
+            // The chip needs a name, and an unnamed group has none — so it
+            // borrows the rail's own wording rather than inventing a second
+            // way to describe the same thing.
+            let label = {
+                let borrow = ctl.catalog.borrow();
+                borrow
+                    .as_ref()
+                    .and_then(|cat| dr_catalog::faces::people(cat.connection()).ok())
+                    .and_then(|people| people.into_iter().find(|p| p.id == person))
+                    .map(|p| {
+                        if p.name.trim().is_empty() {
+                            format!("Unnamed ({} faces)", p.confirmed_faces + p.suggested_faces)
+                        } else {
+                            p.name
+                        }
+                    })
+                    .unwrap_or_else(|| "Person".to_string())
+            };
+
+            ctl.filter.borrow_mut().person = Some(person.0);
+            w.set_library_filter_person_name(label.into());
+
+            // Leaving the Identity screen for the grid is the whole point of
+            // the button: the answer to "who is this" is a set of photographs,
+            // and they are shown where photographs are shown.
+            w.set_show_identity(false);
+            w.set_show_library(true);
+            refilter(&w, &ctl);
+        });
+    }
+
+    {
+        let weak = window.as_weak();
+        let ctl = ctl.clone();
+        window.on_library_filter_person_cleared(move || {
+            let Some(w) = weak.upgrade() else { return };
+            ctl.filter.borrow_mut().person = None;
+            w.set_library_filter_person_name(Default::default());
+            refilter(&w, &ctl);
+        });
+    }
+
     {
         let weak = window.as_weak();
         let ctl = ctl.clone();