refactor(sidecars): drop vestigial start/stop methods (PRD 0024 chunk 3)

Compose-up has owned per-container lifecycle since PRD 0018 ch3;
the .start() / .stop() methods on DockerPipelockProxy /
DockerEgress / DockerGitGate / DockerSupervise (and their
abstractmethod declarations in the four base ABCs) were already
documented as vestigial. With the bundle path in flight
(PRD 0024 ch2), they are truly dead — collapse to nothing.

Changes:
- Removed start/stop methods from the four DockerSidecar
  classes. Plan dataclasses, image/path constants,
  container-name helpers, and the .prepare() methods all stay
  (the renderer + apply path still need them).
- Removed the matching @abstractmethod declarations in the
  base ABCs so concrete subclasses don't have to stub them.
- launch.launch() and prepare.resolve_plan() no longer take
  proxy/git_gate/egress/supervise instance parameters. backend.py
  loses the four instance attributes it threaded through.
  prepare.resolve_plan() instantiates the four classes itself
  to call their .prepare() methods.
- Deleted four integration tests that only exercised the
  removed lifecycle: test_pipelock_sidecar_smoke,
  test_supervise_sidecar, test_git_gate_sidecar,
  test_git_gate_mirror.
- Dropped the .stop-idempotency case in test_orphan_cleanup;
  the network-cleanup cases stay (those test real production
  code).
- Marked test_pipelock_apply @skip pending chunk 4 — its
  bringup helper used .start; chunk 4 rewrites it with direct
  `docker run`.

Dockerfile deletion deferred to chunk 5 (when the bundle flag
default flips) — the legacy compose path still needs
Dockerfile.{egress,git-gate,supervise} until then.

Net: 708 lines removed, 80 added.

533 unit tests + 27 integration tests passing (5 skipped: the
chunk-4-pending case + existing GITEA_ACTIONS guards).

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

claude_bottle/backend/docker/supervise.py

@@ -5,16 +5,12 @@ step (queue dir + current-config staging) from `Supervise`."""
 from __future__ import annotations
 
 import os
-import subprocess
 from pathlib import Path
 
-from ...log import die, info, warn
 from ...supervise import (
-    QUEUE_DIR_IN_CONTAINER,
     SUPERVISE_HOSTNAME,
     SUPERVISE_PORT,
     Supervise,
-    SupervisePlan,
 )
 from . import util as docker_mod
 
@@ -48,84 +44,6 @@ def build_supervise_image() -> None:
 
 
 class DockerSupervise(Supervise):
-    """Brings the supervise sidecar up and down via Docker."""
-
-    def start(self, plan: SupervisePlan) -> str:
-        """Boot the supervise sidecar:
-          1. Build the supervise image (no-op when cache is hot).
-          2. `docker create` on the internal network with
-             `--network-alias supervise` and SUPERVISE_BOTTLE_SLUG in
-             the environ.
-          3. Bind-mount the host queue dir at /run/supervise/queue.
-          4. `docker start`.
-        No egress network — the supervise sidecar does not make
-        outbound calls. Returns the container name."""
-        if not plan.internal_network:
-            die("DockerSupervise.start: plan.internal_network must be set before start")
-        if not plan.queue_dir.is_dir():
-            die(
-                f"DockerSupervise.start: queue dir missing at {plan.queue_dir}; "
-                f"Supervise.prepare must run first"
-            )
-
-        build_supervise_image()
-
-        name = supervise_container_name(plan.slug)
-        info(f"starting supervise sidecar {name} on network {plan.internal_network}")
-
-        create_args = [
-            "docker", "create",
-            "--name", name,
-            "--network", plan.internal_network,
-            "--network-alias", SUPERVISE_HOSTNAME,
-            "-e", f"SUPERVISE_BOTTLE_SLUG={plan.slug}",
-            "-e", f"SUPERVISE_QUEUE_DIR={QUEUE_DIR_IN_CONTAINER}",
-            "-e", f"SUPERVISE_PORT={SUPERVISE_PORT}",
-            "-v", f"{plan.queue_dir}:{QUEUE_DIR_IN_CONTAINER}",
-            SUPERVISE_IMAGE,
-        ]
-
-        create_result = subprocess.run(
-            create_args, capture_output=True, text=True, check=False,
-        )
-        if create_result.returncode != 0:
-            die(
-                f"failed to create supervise sidecar {name}: "
-                f"{create_result.stderr.strip()}"
-            )
-
-        start_result = subprocess.run(
-            ["docker", "start", name], capture_output=True, text=True, check=False,
-        )
-        if start_result.returncode != 0:
-            subprocess.run(
-                ["docker", "rm", "-f", name],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                check=False,
-            )
-            die(
-                f"failed to start supervise sidecar {name}: "
-                f"{start_result.stderr.strip()}"
-            )
-
-        return name
-
-    def stop(self, target: str) -> None:
-        """Idempotent: missing container is success."""
-        if subprocess.run(
-            ["docker", "inspect", target],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            check=False,
-        ).returncode == 0:
-            if subprocess.run(
-                ["docker", "rm", "-f", target],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-                check=False,
-            ).returncode != 0:
-                warn(
-                    f"failed to remove supervise sidecar {target}; "
-                    f"clean up with 'docker rm -f {target}'"
-                )
+    """Docker-flavored Supervise: inherits `.prepare()` from the base.
+    Container lifecycle is owned by compose; per-container
+    `.start()` / `.stop()` were removed in PRD 0024 chunk 3."""