Merge main into the desktop redesign branch

Four conflicts. Three were two people adding to the same spot, and one was a
real collision: main gave the connect bar a REMEMBER tick in the same pass that
this branch took the connect bar off the hosts screen.

REMEMBER is now in the drawer, beside the password box it qualifies. Nothing
about the feature changed — RemembersConnectPassword, its refusal to fire until
the remote has accepted the password, and the six tests over it are main's
untouched — only where it is drawn. The move improves it slightly and it is
worth saying why rather than claiming a merge was neutral: the bar had one row
and had to fit the box, the tick, the authentication note and CONNECT along it,
which is why the tick was a bare "REMEMBER" in tracked capitals. A column has
room to put it under the box as a sentence, where it reads as a property of the
password rather than as a fourth control in a row.

MainWindowViewModel: both sides added members after ShowTerminal — the desktop's
three fixed tabs here, the phone's connect menu on main. They do not interact,
so both are kept, each under its own heading.

TeamsScreen: main added the team's own RENAME, HAND OVER and ARCHIVE, a member's
LastActive, the role a new member arrives as, and the KEY HOLDERS list. This
branch had only bumped the file's font sizes a point. Resolved by taking main's
file whole and re-running the bump over it, so the new controls join the scale
rather than sitting a point below everything around them.

README: both sides described a different head's third pass in the same
paragraph. Both kept.

Two things checked rather than assumed, because this branch moved the furniture
the merged commits sit on. The chrome heights main's terminal work touched are
the phone's, not the desktop's — 44, 42 and 24 are unchanged, so the layout
harness's budget still describes the window. And main's keychain DELETE did not
reach VaultScreen.axaml, whose header this branch rearranged, so the five
buttons that overflowed at the larger type are still five.

2415 tests pass, up from 2369 by the 46 main brought.

tests/DodoSSH.Client.App.Layout.Tests/ScreenLayoutTests.cs

@@ -1495,6 +1495,88 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
             failure)));
 
     /// <summary>Lays the vault screen out at the width it gets once the nav rail has taken its column.</summary>
+    /// <remarks>
+    /// <para>
+    /// The teams screen had no entry in this suite at all until it grew four sections — a rename form, an
+    /// armed confirmation, an invitations list and a key-holders list — plus a second line in the member
+    /// row. Its right-hand column is the narrowest measured here: the window's minimum is 1016, the nav
+    /// rail takes 190 and the team list 268, leaving 558 for everything above.
+    /// </para>
+    /// <para>
+    /// Every list is seeded, and seeded with the long rows rather than the convenient ones — see
+    /// <see cref="StubTeamServer"/>. The two states that hide half the screen, the rename form and the
+    /// confirmation, are measured in their own tests below rather than here, because a control that is
+    /// collapsed when the window is laid out is a control this suite has not checked.
+    /// </para>
+    /// </remarks>
+    [Fact]
+    public Task TheTeamsScreen_FitsWithEveryListPopulated() =>
+        OnTheTeamsScreenAsync(
+            teams => { },
+            window => LayoutHarness.Unreachable(window)
+                .ShouldBeEmpty("the teams screen with members, invitations and key holders"));
+
+    /// <remarks>
+    /// The rename form is drawn in place, above the members list, and pushes everything below it down.
+    /// </remarks>
+    [Fact]
+    public Task TheTeamsScreen_FitsWhileRenamingATeam() =>
+        OnTheTeamsScreenAsync(
+            teams => teams.RenameTeamCommand.Execute(null),
+            window => LayoutHarness.Unreachable(window)
+                .ShouldBeEmpty("the teams screen with the rename form open"));
+
+    /// <remarks>
+    /// The armed confirmation carries two sentences of prose and replaces the header's buttons. It is the
+    /// tallest thing that can appear above the members list, so it is the case most likely to push the
+    /// key-holders list off the bottom.
+    /// </remarks>
+    [Fact]
+    public Task TheTeamsScreen_FitsWhileConfirmingAnArchive() =>
+        OnTheTeamsScreenAsync(
+            teams => teams.ArchiveTeamCommand.Execute(null),
+            window => LayoutHarness.Unreachable(window)
+                .ShouldBeEmpty("the teams screen with the archive confirmation armed"));
+
+    /// <remarks>
+    /// A real <c>TeamsViewModel</c> over a stub server rather than the unlocked vault the rest of this
+    /// suite uses, because nothing on this screen is vault content: it is read from the server on open.
+    /// The session function answers null, which is the state a member is in before anybody has wrapped
+    /// them a key — and it is also the one that draws the most text, since every vault row then carries
+    /// the "waiting for a key" sentence.
+    /// </remarks>
+    private static async Task OnTheTeamsScreenAsync(
+        Action<TeamsViewModel> arrange,
+        Action<Window> assert)
+    {
+        using var teamServer = new StubTeamServer();
+
+        var teams = new TeamsViewModel(() => teamServer, () => null);
+
+        await teams.LoadAsync(Token);
+
+        await LayoutHarness.OnTheUiThreadAsync(
+            () =>
+            {
+                arrange(teams);
+
+                var screen = new TeamsScreen { DataContext = teams };
+
+                var window = LayoutHarness.HostAtMinimumSize(
+                    screen, LayoutHarness.ScreenWidth, LayoutHarness.ScreenHeight);
+
+                try
+                {
+                    assert(window);
+                }
+                finally
+                {
+                    window.Close();
+                }
+            },
+            Token);
+    }
+
     private Task MeasureVaultAsync(Action<IReadOnlyList<string>> assert) =>
         OnTheVaultAsync((_, window) => assert(LayoutHarness.Unreachable(window)));