Take the group headings out of the host grid, and drop onto a group card

A first group turned the wrap of host cards into an accordion: SidebarRows
interleaves a full-width fold-away heading — chevron, name, count — between the
cards, and in a grid that reads as a dropdown somebody left open. The desktop
grid binds VisibleHosts now. The headings and the fold stay for the phone, whose
list has no room for the row of group cards the desktop draws above the grid.

What a heading said, the card says: HostRowViewModel.GroupLabel, resolved once
per reload like the tag names, drawn as an accent chip and absent from a host in
no group — or in one that has been deleted, which is the same thing to look at.

What a heading also was is the drop target, and that moves to the group cards.
Two things go with it. A host dropped onto another host card used to be filed
beside it, which was legible while a heading named the band of cards it landed
in and is guesswork now; it is refused. And UNGROUPED was how a host was dragged
back out of a group; the way out is the picker in its own editor, which is the
one place "no group" can be said in words.

A drag held at either edge of the grid scrolls it. Without that the gesture only
works for whoever can see both ends of it: the group cards are the first thing in
the scroller, the host may be the fortieth card down, and a drag cannot use the
wheel. A step per drag event rather than a timer, so it follows the pointer and
stops when it stops.

The two heading-shaped tests are replaced. TheHostsGridHoldsCardsAndNoGroupHeadings
asserts the grid's contents rather than only measuring them, because a heading
that came back would lay out perfectly cleanly. TheGroupCardsAreWhatAcceptsADroppedHost
raises a real DragOver over both kinds of card and checks the effects and the
mark — the nearest a headless test gets to a gesture no headless test can
synthesise. manual-checks 3.1-3.2 and 7.6-7.9 follow.

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

@@ -325,22 +325,45 @@ public sealed class ScreenLayoutTests : IAsyncLifetime
         });
     }
 
+    /// <summary>
+    /// The grid is cards and nothing else, whatever the vault has been filed into.
+    /// </summary>
     /// <remarks>
-    /// Headings are items in the same list as the cards, drawn from a different template, and they span a
-    /// whole row of the wrap rather than sitting in the flow as another card. Measured with one group
-    /// folded, because a folded heading is the shape whose row is on screen without any of its hosts.
+    /// <para>
+    /// It used to hold the group headings too — a full-width fold-away bar between the cards for each group
+    /// — and in a wrap of cards that read as a dropdown somebody had left open. They are the phone's now.
+    /// This asserts the grid's contents rather than only measuring them, because a heading that came back
+    /// would lay out perfectly cleanly: the harness asks whether a control is inside the window, and a bar
+    /// that spans the width is as inside it as a card is.
+    /// </para>
+    /// <para>
+    /// Measured with every host filed, which is the shape that used to produce the most headings.
+    /// </para>
     /// </remarks>
     [Fact]
-    public async Task TheHostsScreenFitsWithGroupHeadingsInTheGrid()
+    public async Task TheHostsGridHoldsCardsAndNoGroupHeadings()
     {
         await SeedGroupsAsync(3);
 
-        vault.SidebarRows.OfType<SidebarGroupHeader>().Count()
-            .ShouldBe(3, "one heading per group, and no ungrouped heading while nothing is ungrouped");
+        foreach (var host in vault.Hosts.ToArray())
+        {
+            await vault.MoveHostToGroupCommand.ExecuteAsync(
+                new HostGroupMove(host, vault.Groups[0].EntityId));
+        }
 
-        vault.ToggleGroupCommand.Execute(vault.SidebarRows.OfType<SidebarGroupHeader>().First());
+        await OnTheHostsScreenAsync((screen, _) =>
+        {
+            var rows = screen.HostGrid
+                .GetVisualDescendants()
+                .OfType<ListBoxItem>()
+                .Select(item => item.DataContext)
+                .ToList();
 
-        await MeasureHostsAsync(faults => faults.ShouldBeEmpty("with three headings and one folded"));
+            rows.ShouldNotBeEmpty("the seed has to put hosts in the grid");
+            rows.ShouldAllBe(row => row is HostRowViewModel);
+        });
+
+        await MeasureHostsAsync(faults => faults.ShouldBeEmpty("with three groups and every host filed"));
     }
 
     /// <remarks>