fix(remote): stop the flush losing a chunk, and reset the host form's wake fields

Own review pass over the PR:

- `_flush` took the chunk out of the buffer only AFTER awaiting the write. Input
  arriving during that await is enqueued (`waking` is still set, so it takes the
  buffer path), and the 4 KB cap then drops the OLDEST chunk — which is the one
  already on its way to the pane. The `shift()` that followed removed the NEXT
  chunk instead, so the drop-oldest bookkeeping silently lost a chunk that was
  never written, while the log line blamed the one that was. The chunk is now
  removed before the await and re-inserted at the FRONT on a failed write, so the
  order of the queue behind it is preserved. Regression test: a chunk enqueued
  during the first write of a full buffer must still reach the pane (red against
  the old order).
- `showCreateCaseModal()` reset the remote-host form fields but not the two new
  wake inputs, so one host's MAC/command carried over into the next host that
  form saved.
- The banner's pre-poll `wakeConfigured` labelled a command-only host as 'mac'.
  Nothing reads the distinction, but the field is documented as which path is
  configured, so it says the truth until the first poll corrects it.
- Stale `resolveRemote` comment ("only for sessions that have no usable target of
  their own"): after the host config became authoritative in both directions it is
  consulted on the TTL regardless.

src/remote-wake.ts

@@ -690,14 +690,22 @@ export class RemoteWakeRegistry {
   private async _flush(state: WakeState, session: WakeableSession): Promise<void> {
     while (state.pending.length > 0) {
       const chunk = state.pending[0];
+      // Take the chunk OUT before awaiting the write. Input arriving during the await is
+      // enqueued by `handleInput` (a wake is still in flight, so it takes the buffer
+      // path), and `appendBoundedPending` may then drop the OLDEST chunk to stay under
+      // the cap — which would be this one, already on its way to the pane. Shifting
+      // afterwards removed the NEXT chunk instead, so the drop-oldest bookkeeping lost a
+      // chunk that was never written while the log line blamed the one that was.
+      state.pending = state.pending.slice(1);
       const ok = await session.writeViaMux(chunk).catch(() => false);
       if (!ok) {
+        // Retain it, IN ORDER: a failed write must not reorder the queue behind it.
+        state.pending = [chunk, ...state.pending];
         this.deps.log?.(
           `[RemoteWake] flush failed for session ${session.id} — ${state.pending.length} chunk(s) retained`
         );
         return;
       }
-      state.pending.shift();
     }
   }
 }