refactor(api): namespaced SDK + dedicated transport layer

Restructure the Python API and internals around composable namespaces and
a standalone transport/endpoint layer. Bump to 0.12.0.

Python API:
- Replace flat methods (b.tabs_list(), b.group_list()) with namespaces:
  b.nav, b.tabs, b.groups, b.windows, b.dom, b.extract, b.page, b.storage,
  b.cookies, b.session, b.perf, b.extension.
- Shrink browser_cli/__init__.py to a thin composition root; move all
  behaviour into browser_cli/sdk/ (one module per namespace + factories,
  base, routing).

Internals:
- Add browser_cli/transport.py and remote_transport.py to isolate IPC from
  command logic; client.py now delegates instead of owning transport.
- Add browser_cli/endpoints.py for endpoint resolution and
  browser_cli/errors.py for shared error types.
- Extract markdown rendering into browser_cli/markdown.py (out of extract).
- Add USER_AGENT to version_manager.

Tooling & tests:
- Add justfile with common dev tasks.
- Update CLI commands and demo to the namespaced API.
- Rework tests for the new layout; add test_transport.py and
  test_refactor_boundaries.py to lock in module boundaries.

BREAKING CHANGE: flat API methods are removed in favour of namespaces
(e.g. b.tabs_list() -> b.tabs.list(), b.group_list() -> b.groups.list()).

browser_cli/commands/groups.py

@@ -1,12 +1,11 @@
 import click
-from browser_cli.commands import _handle, _handle_multi, _multi_browser_targets
+from browser_cli.commands import client_from_ctx, gentle_mode_option, handle_errors, print_counts
 from rich.console import Console
 from rich.table import Table
 
 console = Console()
 
-
-def _print_groups(groups: list[dict], *, show_browser: bool = False) -> None:
+def _print_groups(groups, *, show_browser: bool = False) -> None:
     if not groups:
         console.print("[yellow]No groups found[/yellow]")
         return
@@ -20,128 +19,88 @@ def _print_groups(groups: list[dict], *, show_browser: bool = False) -> None:
     table.add_column("Tabs", width=6)
     for g in groups:
         row = [
-            g.get("browser", "") if show_browser else None,
-            str(g.get("id", "")),
-            g.get("title") or "",
-            g.get("color") or "",
-            "yes" if g.get("collapsed") else "no",
-            str(g.get("tabCount", "")),
+            (g.browser or "") if show_browser else None,
+            str(g.id),
+            g.title or "",
+            g.color or "",
+            "yes" if g.collapsed else "no",
+            str(g.tab_count),
         ]
         table.add_row(*[value for value in row if value is not None])
     console.print(table)
 
-
 @click.group("groups")
 def group_group():
     """Manage tab groups."""
 
-
 @group_group.command("list")
+@handle_errors
 def group_list():
     """List all tab groups."""
-    targets = _multi_browser_targets()
-    if targets:
-        groups = []
-        for target in targets:
-            result = _handle_multi("group.list", profile=target.profile, remote=target.remote)
-            if result is None:
-                continue
-            groups.extend({**group, "browser": target.display_name} for group in result)
-        if not groups:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        _print_groups(groups, show_browser=True)
-        return
-    groups = _handle("group.list")
-    _print_groups(groups or [])
-
+    groups = client_from_ctx().groups.list()
+    _print_groups(groups, show_browser=any(g.browser for g in groups))
 
 @group_group.command("tabs")
 @click.argument("group_id", type=int)
+@handle_errors
 def group_tabs(group_id):
     """List tabs inside a group."""
     from browser_cli.commands.tabs import _print_tabs
-    tabs = _handle("group.tabs", {"groupId": group_id})
-    _print_tabs(tabs or [])
-
+    _print_tabs(client_from_ctx().groups.tabs(group_id))
 
 @group_group.command("count")
+@handle_errors
 def group_count():
     """Count all tab groups."""
-    targets = _multi_browser_targets()
-    if targets:
-        table = Table(show_header=True, header_style="bold cyan")
-        table.add_column("Browser")
-        table.add_column("Groups", justify="right")
-        total = 0
-        rows = 0
-        for target in targets:
-            count = _handle_multi("group.count", profile=target.profile, remote=target.remote)
-            if count is None:
-                continue
-            count = int(count or 0)
-            total += count
-            rows += 1
-            table.add_row(target.display_name, str(count))
-        if rows == 0:
-            console.print("[red]Error:[/red] Cannot resolve a browser socket automatically.")
-            raise SystemExit(1)
-        table.add_row("Total", str(total))
-        console.print(table)
-        return
-    count = _handle("group.count")
-    console.print(f"[bold]{count}[/bold] group(s)")
-
+    print_counts(client_from_ctx().groups.count(), "group")
 
 @group_group.command("query")
 @click.argument("search")
+@handle_errors
 def group_query(search):
     """Search groups by name."""
-    groups = _handle("group.query", {"search": search})
-    _print_groups(groups or [])
-
+    _print_groups(client_from_ctx().groups.query(search))
 
 @group_group.command("close")
 @click.argument("group_id", type=int)
-@click.option("--gentle-mode", type=click.Choice(["auto", "normal", "gentle", "ultra"]), default="auto", show_default=True, help="Throttle mode for large group operations.")
+@gentle_mode_option("Throttle mode for large group operations.")
+@handle_errors
 def group_close(group_id, gentle_mode):
     """Close (ungroup and optionally close) a tab group."""
-    _handle("group.close", {"groupId": group_id, "gentleMode": gentle_mode})
+    client_from_ctx().groups.close(group_id, gentle_mode=gentle_mode)
     console.print(f"[green]Group {group_id} closed[/green]")
 
-
 @group_group.command("create")
 @click.argument("name")
+@handle_errors
 def group_create(name):
     """Create a new tab group with NAME."""
-    result = _handle("group.open", {"name": name})
-    gid = result.get("id") if isinstance(result, dict) else result
-    console.print(f"[green]Created group '{name}'[/green] (id: {gid})")
-
+    group = client_from_ctx().groups.create(name)
+    console.print(f"[green]Created group '{name}'[/green] (id: {group.id})")
 
 @group_group.command("add-tab")
 @click.argument("group")
 @click.argument("url", required=False)
+@handle_errors
 def group_add_tab(group, url):
     """Open a new tab (optionally at URL) inside GROUP (name or ID)."""
-    result = _handle("group.add_tab", {"group": group, "url": url})
-    tab_id = result.get("tabId") if isinstance(result, dict) else result
+    tab_id = client_from_ctx().groups.add_tab(group, url)
     label = url or "new tab"
     console.print(f"[green]Opened {label}[/green] in group '{group}' (tab id: {tab_id})")
 
-
 @group_group.command("move")
 @click.argument("group")
 @click.option("-f", "--forward", "forward", is_flag=True, help="Move group one position to the right")
 @click.option("-b", "--backward", "backward", is_flag=True, help="Move group one position to the left")
 @click.option("-r", "--right", "forward", is_flag=True, help="Move group one position to the right")
 @click.option("-l", "--left", "backward", is_flag=True, help="Move group one position to the left")
+@handle_errors
 def group_move(group, forward, backward):
     """Move a tab group forward/backward or right/left (name or ID)."""
     if not forward and not backward:
         console.print("[red]Specify --forward/--right or --backward/--left[/red]")
         raise SystemExit(1)
-    result = _handle("group.move", {"group": group, "forward": forward, "backward": backward})
+    result = client_from_ctx().groups.move(group, forward=forward, backward=backward)
     if isinstance(result, dict) and not result.get("moved"):
         console.print(f"[yellow]Group '{group}' is already at the {'end' if forward else 'start'}[/yellow]")
     else: