refactor(backend): thin the docker/firecracker/macos-container package inits

The three concrete-backend package inits eagerly imported their
`*BottleBackend` (which pulls the whole framework), so importing any leaf under
them (e.g. `backend.docker.util`) paid ~78 modules. Give each the same thin
`__getattr__` treatment as the top-level backend package: re-export the public
class(es) lazily on first access, with a TYPE_CHECKING block for checkers.

`import bot_bottle.backend.docker.util` drops from 78 -> 6 bot_bottle modules;
the docker/firecracker/macos-container packages themselves are ~3 each. All
`from bot_bottle.backend.docker import DockerBottleBackend` call-sites and the
lazy selection path keep working.

This is what makes backend leaves cheap — and unblocks moving docker_cmd into
backend/docker/util if we want.

Full unit suite green (2243).

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

bot_bottle/backend/docker/__init__.py

@@ -11,18 +11,42 @@ The bulk of the implementation lives in sibling modules:
   - launch:               bring-up + teardown context manager
   - cleanup:              orphan enumeration, removal, active listing
   - backend:              DockerBottleBackend façade wiring the above
+  - infra:                DockerInfraService (the per-host infra container)
 
-This file only re-exports the public names so
-`from bot_bottle.backend.docker import DockerBottleBackend` keeps
-working.
+Thin by design: the public names are re-exported lazily via `__getattr__`, so
+importing a leaf like `backend.docker.util` doesn't drag `DockerBottleBackend`
+(and the whole framework it pulls) into memory.
 """
 
 from __future__ import annotations
 
-from .backend import DockerBottleBackend
-from .bottle import DockerBottle
-from .bottle_cleanup_plan import DockerBottleCleanupPlan
-from .bottle_plan import DockerBottlePlan
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .backend import DockerBottleBackend
+    from .bottle import DockerBottle
+    from .bottle_cleanup_plan import DockerBottleCleanupPlan
+    from .bottle_plan import DockerBottlePlan
+
+
+_LAZY_MODULES: dict[str, str] = {
+    "DockerBottleBackend": "backend",
+    "DockerBottle": "bottle",
+    "DockerBottleCleanupPlan": "bottle_cleanup_plan",
+    "DockerBottlePlan": "bottle_plan",
+}
+
+
+def __getattr__(name: str) -> Any:
+    mod = _LAZY_MODULES.get(name)
+    if mod is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from importlib import import_module
+
+    value = getattr(import_module(f"{__name__}.{mod}"), name)
+    globals()[name] = value
+    return value
+
 
 __all__ = [
     "DockerBottle",

bot_bottle/backend/firecracker/__init__.py

@@ -1,7 +1,25 @@
-"""Firecracker backend: Linux KVM microVM isolation (issue #342)."""
+"""Firecracker backend: Linux KVM microVM isolation (issue #342).
+
+Thin by design: `FirecrackerBottleBackend` is re-exported lazily via
+`__getattr__`, so importing a leaf module under this package doesn't drag the
+backend (and the framework it pulls) into memory.
+"""
 
 from __future__ import annotations
 
-from .backend import FirecrackerBottleBackend
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .backend import FirecrackerBottleBackend
+
+
+def __getattr__(name: str) -> Any:
+    if name == "FirecrackerBottleBackend":
+        from .backend import FirecrackerBottleBackend
+
+        globals()[name] = FirecrackerBottleBackend
+        return FirecrackerBottleBackend
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 __all__ = ["FirecrackerBottleBackend"]

bot_bottle/backend/macos_container/__init__.py

@@ -1,10 +1,29 @@
 """macOS Apple Container backend.
 
-Selectable via `BOT_BOTTLE_BACKEND=macos-container`. This package owns
-the Apple `container` CLI integration; launch remains gated until the
-gateway network enforcement shape is implemented.
+Selectable via `BOT_BOTTLE_BACKEND=macos-container`. This package owns the Apple
+`container` CLI integration; launch remains gated until the gateway network
+enforcement shape is implemented.
+
+Thin by design: `MacosContainerBottleBackend` is re-exported lazily via
+`__getattr__`, so importing a leaf module under this package doesn't drag the
+backend (and the framework it pulls) into memory.
 """
 
-from .backend import MacosContainerBottleBackend
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .backend import MacosContainerBottleBackend
+
+
+def __getattr__(name: str) -> Any:
+    if name == "MacosContainerBottleBackend":
+        from .backend import MacosContainerBottleBackend
+
+        globals()[name] = MacosContainerBottleBackend
+        return MacosContainerBottleBackend
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 __all__ = ["MacosContainerBottleBackend"]