fix(ux): cap the in-app toast stack; stable "Unread First" room sort

- Toast queue: a burst of notifications appended unboundedly and could cover the
  viewport. Cap at 5 in the atom writer, dropping the OLDEST non-sticky toast
  (sticky = action toasts requiring a click, never dropped). The drop scan
  excludes the just-appended newest (`length - 1` bound) so a fresh toast is
  never the one eaten when the cap is full of stickies — it stretches instead.
  Container gains a maxHeight + overflowY safety net and scrolls the newest
  (bottom) toast into view if the stack ever overflows. +4 unit tests incl. the
  cap-full-of-stickies boundary.

- "Unread First" room sort left the entire read tail (all counts tie at 0) in
  arbitrary Map order. factoryRoomIdByUnread now breaks ties by recent activity.
  Relocated from Home.tsx (module-private) to utils/sort.ts (exported, pure) and
  unit-tested (equal-count and read-tail cases fall back to activity).

Bug-hunt findings from LOTUS_TODO. Three review passes: the second caught that
the cap could silently drop the newest notification when full of stickies (real
bug, untested boundary) — fixed and covered; a third traced the corrected loop.
Gate-green (tsc, eslint, prettier, 920 tests, build).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/app/state/toast.ts

@@ -46,12 +46,28 @@ export const createErrorToast = (
 
 const baseAtom = atom<ToastNotif[]>([]);
 
+// Cap concurrent toasts so a burst (e.g. many rooms lighting up while focused)
+// can't stack unbounded and cover the viewport.
+const MAX_TOASTS = 5;
+
 // Write-only setter used in ClientNonUIFeatures
 export const toastQueueAtom = atom<ToastNotif[], [ToastNotif | null], void>(
   (get) => get(baseAtom),
   (get, set, notif) => {
     if (notif === null) return; // no-op guard
-    set(baseAtom, [...get(baseAtom), notif]);
+    const next = [...get(baseAtom), notif];
+    // Over cap: drop the oldest NON-sticky toasts (transient message/error
+    // toasts auto-dismiss anyway); never drop a sticky action toast, which
+    // requires a click. The `length - 1` bound excludes the just-appended
+    // newest, so a fresh toast is never the one dropped — if everything older
+    // is sticky the cap simply stretches rather than eating the new notice.
+    for (let i = 0; i < next.length - 1 && next.length > MAX_TOASTS; i += 1) {
+      if (!next[i].sticky) {
+        next.splice(i, 1);
+        i -= 1;
+      }
+    }
+    set(baseAtom, next);
   },
 );