Add leave_game and enrich game_status for frontend integration

- leave_game: explicit exit from the lobby/game. Before start it frees
  the seat; after start it keeps the seat (token reconnect still works)
  and marks the player offline, dropping the game once empty.
- Seat assignment now picks the lowest free order, so leaving a lobby
  before start no longer collides order numbers on the next join.
- game_status is now self-contained: adds players roster
  (order/name/connected), series_number, round_number and cards_in_round
  (= trick count / max bid), so the game view no longer has to stitch the
  lobby snapshot.
- Add Game.player_by_order helper.

Tests: +5 (roster/round meta, leave-before-start frees seat, leave drops
empty game, leave started game keeps seat offline, leave noop). Suite: 34.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

test_socket.py

@@ -168,6 +168,54 @@ class SocketLayerCase(unittest.IsolatedAsyncioTestCase):
         await api.reconnect_to_game("zzz", gid, "wrong-token")
         self.assertEqual(self.last("error")["data"]["error"], "Neplatny token pre pripojenie.")
 
+    # --- self-contained game_status --------------------------------------
+
+    async def test_game_status_carries_roster_and_round_meta(self):
+        gid = await self.make_started_game()
+        self.emits.clear()
+        await api.game_status("s0")
+        data = self.last("game_status")["data"]
+        self.assertEqual(data["round_number"], 0)
+        self.assertEqual(data["cards_in_round"], 8)
+        self.assertEqual(data["series_number"], 0)
+        roster = data["players"]
+        self.assertEqual([p["order"] for p in roster], [0, 1, 2, 3])
+        self.assertEqual([p["name"] for p in roster], ["P0", "P1", "P2", "P3"])
+        self.assertTrue(all(p["connected"] for p in roster))
+
+    # --- leave_game -------------------------------------------------------
+
+    async def test_leave_before_start_frees_the_seat(self):
+        gid = await self.make_game()
+        await api.register_player("s0", gid, "P0")
+        await api.register_player("s1", gid, "P1")
+        await api.leave_game("s0")  # order 0 leaves
+        self.assertNotIn("s0", api.sessions)
+        self.assertEqual([p.order for p in api.games[gid].players], [1])
+        # the freed seat 0 is reused by the next joiner
+        await api.register_player("s2", gid, "P2")
+        self.assertEqual(api.sessions["s2"]["order"], 0)
+
+    async def test_leave_last_lobby_player_drops_game(self):
+        gid = await self.make_game()
+        await api.register_player("s0", gid, "P0")
+        await api.leave_game("s0")
+        self.assertNotIn(gid, api.games)
+
+    async def test_leave_started_game_keeps_seat_marks_offline(self):
+        gid = await self.make_started_game()
+        await api.leave_game("s1")
+        self.assertNotIn("s1", api.sessions)
+        player = api.games[gid].player_by_order(1)
+        self.assertIsNotNone(player)          # seat kept for reconnect
+        self.assertFalse(player.connected)
+        self.assertIn(gid, api.games)         # others still in
+
+    async def test_leave_without_session_is_a_noop(self):
+        await api.leave_game("ghost")
+        # no exception, and no error emitted to a non-participant
+        self.assertEqual(self.events("error"), [])
+
     # --- disconnect & cleanup --------------------------------------------
 
     async def test_disconnect_marks_player_then_drops_empty_game(self):