feat(session/gamestream): the compat plane learns a game's lifetime too

Moonlight sessions had neither direction of the session⇄game binding: a game
exiting left the player looking at a desktop, and a session ending never touched
the game. The machinery for both landed with the native plane; this wires it up.

The compat plane had no way to say "this is over" — RTSP carries no close code —
so `/cancel`, the management stop and a game exiting all looked exactly like a
client vanishing. They now set a session quit flag, which is what lets the
virtual display skip its keep-alive linger for a real stop and what the
end-game-on-session-end policy reads to tell a decision from a network blip. A
drop still lingers, and still gets its reconnect window.

Moonlight can't resume a session, so a client coming back for a game it left
behind does it by launching the title again — that reclaims the waiting game
before anything starts, rather than letting the old window close on the copy the
player is now holding.

Both planes now resolve a launch through one lookup (`resolve_launch`), so a
GameStream title arrives with the same identity and the same detect signals a
native one does; `resolve_session_launch`/`launch_command` were the older,
identity-less half of that and are gone. A Moonlight game also has no
live-session entry to hang off, so the status surface gains a slot for it —
without it the Dashboard would show a stream with no game while one was running.

Gates on .21: check + clippy --all-targets clean, 296 tests (293 + 3), fmt
CI-parity.

crates/punktfunk-host/src/gamelease.rs

@@ -950,6 +950,51 @@ pub fn on_session_end(lease: &GameLease, deliberate: bool, fingerprint: Option<&
     }
 }
 
+/// Applies [`on_session_end`] when a session's stream loop exits, whichever way it exits (`return`,
+/// `?`, a `break` out of the loop, a panic-unwind) — the same RAII shape the per-title prep/undo
+/// guard uses, for the same reason: teardown paths are many and easy to miss one of.
+///
+/// Reading `quit` at **drop** time is the point: it is what distinguishes a client that deliberately
+/// stopped (or an operator who did) from one that merely vanished, and that distinction is the whole
+/// safety story for [`GameOnSessionEnd::Always`](crate::session_settings::GameOnSessionEnd::Always) —
+/// a vanish gets a reconnect window, a deliberate stop does not.
+///
+/// Both planes use it, so "the session ended" means the same thing to a game whichever way the client
+/// was talking to the host.
+pub struct SessionGuard {
+    lease: GameLease,
+    quit: Arc<AtomicBool>,
+    /// Hex client fingerprint, so a reconnecting client can reclaim its own game and nothing else.
+    fingerprint: Option<String>,
+}
+
+impl SessionGuard {
+    /// Bind `lease` to the calling session's lifetime. `quit` is the session's deliberate-stop flag,
+    /// read at drop; `fingerprint` identifies the client allowed to reclaim the game on reconnect.
+    pub fn new(lease: GameLease, quit: Arc<AtomicBool>, fingerprint: Option<String>) -> Self {
+        Self {
+            lease,
+            quit,
+            fingerprint,
+        }
+    }
+
+    /// The lease's shared state, for the status surface.
+    pub fn shared(&self) -> Arc<LeaseShared> {
+        self.lease.shared()
+    }
+}
+
+impl Drop for SessionGuard {
+    fn drop(&mut self) {
+        on_session_end(
+            &self.lease,
+            self.quit.load(Ordering::SeqCst),
+            self.fingerprint.as_deref(),
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;