Fix the folder picker stuck on "Loading…"

The picker set loading=true and nothing ever cleared it, because
browser_loaded() was never called — my earlier edit to replace the stub
silently failed to apply after cargo fmt reindented the code it matched
against. The stale stub was still writing folder names into the status
line, which is the list visible under the selector.

Verified by grep before and after: browser_loaded had zero call sites,
now two.

Two related defects fixed while in there. Both timers polled their
channel with `if let Ok(..)`, so a worker thread that died without
sending left the screen on "Loading…" or "Connecting…" forever. Both now
treat Disconnected as terminal.

The first attempt at that fix introduced a bug of its own: a separate
probe call consumed a pending message and discarded it, so a successful
login would have vanished. The login poller now drains in one loop with
disconnection as a match arm, and only reports failure when the flow had
not already completed.

Lesson worth recording: verify a replacement applied rather than trusting
the edit succeeded. A silently-skipped replace looks identical to a
successful one until the feature is used.

43 tests in dr-ui.

ui/dr-ui/src/develop.rs

@@ -477,6 +477,95 @@ mod tests {
         assert_eq!(h, 200);
     }
 
+    #[test]
+    fn the_curve_collapses_to_a_single_row() {
+        // Ten point parameters must appear as one curve control, not ten
+        // sliders — otherwise the widget and the sliders both render and the
+        // panel shows the same values twice.
+        let graph = EditGraph::default_chain();
+        let curve_cap = graph
+            .capabilities()
+            .into_iter()
+            .find(|c| c.id == curve::ID)
+            .expect("the chain includes a tone curve");
+
+        assert_eq!(curve_cap.params.len(), curve::POINTS * 2);
+        let presentation = curve_cap
+            .presentation
+            .as_ref()
+            .expect("the curve declares a widget");
+        assert_eq!(presentation.widget, WidgetKind::Curve);
+        // Every parameter is owned by the widget, so none is left over to be
+        // rendered as a stray slider.
+        assert_eq!(presentation.params.len(), curve_cap.params.len());
+    }
+
+    #[test]
+    fn curve_point_parameters_are_contiguous() {
+        // The widget addresses points by offset from the first. Were they
+        // interleaved with anything else, dragging a point would write to
+        // the wrong parameter.
+        let graph = EditGraph::default_chain();
+        let cap = graph
+            .capabilities()
+            .into_iter()
+            .find(|c| c.id == curve::ID)
+            .expect("tone curve present");
+        let presentation = cap.presentation.as_ref().expect("declares a widget");
+
+        let base = cap
+            .params
+            .iter()
+            .position(|p| p.id == presentation.params[0])
+            .expect("first point is a parameter");
+        for (i, id) in presentation.params.iter().enumerate() {
+            assert_eq!(
+                cap.params[base + i].id,
+                *id,
+                "point parameter {i} is out of order"
+            );
+        }
+    }
+
+    #[test]
+    fn curve_samples_start_on_the_diagonal() {
+        // A fresh curve is the identity, so the drawn line must be the 45°
+        // diagonal — anything else means the widget opens showing a shape
+        // the image does not have.
+        let mut xs = [0.0f32; curve::POINTS];
+        let mut ys = [0.0f32; curve::POINTS];
+        for i in 0..curve::POINTS {
+            let t = i as f32 / (curve::POINTS - 1) as f32;
+            xs[i] = t;
+            ys[i] = t;
+        }
+        for i in 0..=20 {
+            let x = i as f32 / 20.0;
+            let y = curve::evaluate(&xs, &ys, x);
+            assert!((y - x).abs() < 1e-4, "at {x} the identity gave {y}");
+        }
+    }
+
+    #[test]
+    fn sorting_enforces_a_minimum_gap() {
+        // Two points dragged onto each other would divide by zero in the
+        // spline; the drawn curve must survive it exactly as the shader does.
+        let mut xs = [0.5, 0.5, 0.5, 0.5, 0.5];
+        sort_with_gap(&mut xs);
+        for i in 1..xs.len() {
+            assert!(xs[i] > xs[i - 1], "not separated: {xs:?}");
+        }
+    }
+
+    #[test]
+    fn sorting_orders_reversed_points() {
+        let mut xs = [0.9, 0.7, 0.5, 0.3, 0.1];
+        sort_with_gap(&mut xs);
+        for i in 1..xs.len() {
+            assert!(xs[i] > xs[i - 1], "not sorted: {xs:?}");
+        }
+    }
+
     #[test]
     fn routing_indices_map_back_to_the_right_parameter() {
         // A wrong index would silently move the wrong slider's value, which