refactor(bottles): two-phase cleanup parallel to prepare/launch

cmd_cleanup used to only sweep running containers via `docker ps`,
missing stopped pipelock sidecars and orphaned networks entirely. On
my host the new version surfaced ~10 stranded networks left behind by
SIGKILLed sessions — the kind of thing the old command implied it was
handling.

New shape, symmetric with start:
- BottleCleanupPlan (abstract, in bottles/__init__.py) with `print` +
  `empty` abstract members.
- DockerBottleCleanupPlan (concrete, in bottles/docker.py) carrying
  the resolved tuples of containers and networks.
- BottlePlatform gains abstract prepare_cleanup() + cleanup(plan).
  DockerBottlePlatform implements both:
    - prepare_cleanup: docker ps -a + docker network ls, both
      filtered to ^claude-bottle-, sorted for stable output.
    - cleanup: docker rm -f containers first (they hold the network
      attachment), then docker network rm.
- cmd_cleanup is now ~25 lines: prepare → print → y/N → cleanup.

claude_bottle/bottles/docker.py

@@ -34,7 +34,7 @@ from .. import skills as skills_mod
 from .. import ssh as ssh_mod
 from ..env_resolve import env_resolve
 from ..log import die, info
-from . import BottlePlan, BottlePlatform, BottleSpec
+from . import BottleCleanupPlan, BottlePlan, BottlePlatform, BottleSpec
 
 
 # Where the repo root lives, for `docker build` context. Computed once.
@@ -120,6 +120,31 @@ class DockerBottlePlan(BottlePlan):
         print(file=sys.stderr)
 
 
+# --- Cleanup plan ----------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class DockerBottleCleanupPlan(BottleCleanupPlan):
+    """Resources DockerBottlePlatform.cleanup will remove. Produced by
+    `prepare_cleanup` from a snapshot of `docker ps -a` + `docker
+    network ls`; sorted so the y/N output is stable."""
+
+    containers: tuple[str, ...]
+    networks: tuple[str, ...]
+
+    @property
+    def empty(self) -> bool:
+        return not self.containers and not self.networks
+
+    def print(self) -> None:
+        print(file=sys.stderr)
+        for name in self.containers:
+            info(f"container: {name}")
+        for name in self.networks:
+            info(f"network:   {name}")
+        print(file=sys.stderr)
+
+
 # --- Bottle handle ---------------------------------------------------------
 
 
@@ -438,3 +463,67 @@ class DockerBottlePlatform(BottlePlatform):
             )
 
         return in_container_prompt_path if agent.prompt else None
+
+    # --- Cleanup ---
+
+    def prepare_cleanup(self) -> DockerBottleCleanupPlan:
+        """Enumerate all claude-bottle-prefixed containers (running or
+        stopped) and networks. No removals — caller confirms first."""
+        docker_mod.require_docker()
+
+        # `docker ps -a --filter name=...` uses regex matching; anchor at
+        # the start so we don't pick up containers that merely contain
+        # "claude-bottle-" mid-name.
+        cr = subprocess.run(
+            [
+                "docker", "ps", "-a",
+                "--filter", "name=^claude-bottle-",
+                "--format", "{{.Names}}",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        containers = tuple(sorted(
+            line for line in (cr.stdout or "").splitlines() if line
+        ))
+
+        # `docker network ls --filter name=...` uses substring matching.
+        # "claude-bottle-" is specific enough that false positives are
+        # not a concern.
+        nr = subprocess.run(
+            [
+                "docker", "network", "ls",
+                "--filter", "name=claude-bottle-",
+                "--format", "{{.Name}}",
+            ],
+            capture_output=True,
+            text=True,
+        )
+        networks = tuple(sorted(
+            line for line in (nr.stdout or "").splitlines() if line
+        ))
+
+        return DockerBottleCleanupPlan(containers=containers, networks=networks)
+
+    def cleanup(self, plan: BottleCleanupPlan) -> None:
+        """Remove the containers and networks listed in the plan.
+        Containers first; networks would refuse to delete while
+        containers are still attached."""
+        assert isinstance(plan, DockerBottleCleanupPlan), (
+            f"DockerBottlePlatform.cleanup expects DockerBottleCleanupPlan, "
+            f"got {type(plan).__name__}"
+        )
+        for name in plan.containers:
+            info(f"removing container {name}")
+            subprocess.run(
+                ["docker", "rm", "-f", name],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        for name in plan.networks:
+            info(f"removing network {name}")
+            subprocess.run(
+                ["docker", "network", "rm", name],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )