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.Tests/ShellFlowTests.cs

@@ -3368,9 +3368,9 @@ public sealed class ShellFlowTests : IAsyncLifetime
     }
 
     /// <remarks>
-    /// What dragging a row onto a heading does. It is the same write the editor makes — one field of the
-    /// host, pushed straight away — reached without opening a form, because filing thirty imported machines
-    /// through the editor is thirty rounds of open, pick, save.
+    /// What dragging a host card onto a group card does. It is the same write the editor makes — one field
+    /// of the host, pushed straight away — reached without opening a form, because filing thirty imported
+    /// machines through the editor is thirty rounds of open, pick, save.
     /// </remarks>
     [Fact]
     public async Task MovingAHostToAGroup_FilesItAndLeavesItSelected()
@@ -3389,15 +3389,21 @@ public sealed class ShellFlowTests : IAsyncLifetime
         vault.Hosts.Single().Host.GroupId.ShouldBe(group);
         vault.SelectedHost.ShouldNotBeNull().EntityId.ShouldBe(host.EntityId, "the reload replaces every row");
 
-        // Under the group's own heading now, which is the thing the drop was aiming at.
+        // Under the group's own heading now, which is what the phone's list draws.
         vault.SidebarRows.OfType<SidebarGroupHeader>()
             .Single(header => header.GroupId == group)
             .Count.ShouldBe(1);
 
-        // And back out again, which is what the ungrouped heading is a target for.
+        // And the name on the card, which is what the desktop's grid draws instead of that heading — the one
+        // thing on screen that changes where the host was dropped rather than where it came from.
+        vault.Hosts.Single().GroupLabel.ShouldBe("production");
+        vault.Hosts.Single().HasGroup.ShouldBeTrue();
+
+        // And back out again, which is what the host's own editor is for now that the drop has one target.
         await vault.MoveHostToGroupCommand.ExecuteAsync(new HostGroupMove(vault.Hosts.Single(), null));
 
         vault.Hosts.Single().Host.GroupId.ShouldBeNull();
+        vault.Hosts.Single().HasGroup.ShouldBeFalse("and the chip goes with it");
     }
 
     /// <remarks>
@@ -3454,9 +3460,13 @@ public sealed class ShellFlowTests : IAsyncLifetime
         vault.Groups.ShouldBeEmpty();
         vault.HasGroups.ShouldBeFalse();
 
-        // The host keeps the id, which is what makes this cheap; the sidebar is what resolves it to nothing.
+        // The host keeps the id, which is what makes this cheap; the list is what resolves it to nothing.
         vault.Hosts.Single().Host.GroupId.ShouldBe(groupId);
         vault.SidebarRows.ShouldAllBe(row => row is HostRowViewModel);
+
+        // The card says the same thing the phone's list does: nothing. An id nobody can name is drawn as no
+        // group rather than as a GUID on a chip.
+        vault.Hosts.Single().GroupLabel.ShouldBeEmpty();
     }
 
     /// <remarks>