Adds `--entrypoint <PROGRAM>` to the boxlite run command, mirroring
the Docker CLI flag of the same name. When set, the positional command
tail is re-routed into BoxOptions::cmd so the image's init runs the
user's command — matching `docker run --entrypoint X image arg1 arg2`
semantics.

Motivating use case is dind: the `docker:dind` image's ENTRYPOINT
(dockerd-entrypoint.sh) generates TLS certs and then `exec "$@"` with
the args. With no args, exec is a no-op and the script exits — which
tears down the container's PID namespace and SIGKILLs every process
inside. `--entrypoint sh` lets the caller run a probe script directly
as PID 1, bypassing the image entrypoint entirely.

The foreground exec for `boxlite run`'s stdio attach is replaced with
`sleep infinity` when --entrypoint is set, so when the init process
exits the container tears down the foreground sleep and `boxlite run`
returns cleanly.

BoxOptions::entrypoint and ::cmd already existed on the Rust API
surface (used by SDKs); this commit only adds the CLI flag.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Boxlite's lean libkrunfw kernel lacks BRIDGE/VETH/NETFILTER/NF_NAT/
IPTABLE_*/NF_TABLES/POSIX_MQUEUE — exactly the subsystems docker /
docker-compose lean on. Phase A (the previous commit set) put the
userspace plumbing (full caps + cgroup rw under `--support-docker`)
in place; this commit adds the kernel half so `docker build` /
`docker run` work end-to-end inside the box. Issue boxlite-ai#276.

What this commit adds:

  - dind-configs/overlay-dind_{x86_64,aarch64}: a Kconfig overlay
    applied on top of the lean config when building the dind blob.
    Enables every CONFIG_* docker / docker-compose require, all =y
    (the guest has no /lib/modules and can't load modules at runtime).

  - scripts/build/build-libkrunfw-dind.sh + `make libkrunfw-dind`:
    merges the lean config + dind overlay, drives the upstream
    libkrunfw Makefile to produce a 21 MB libkrunfw-dind.so.5,
    SONAME-stamped distinct from the lean blob so the two can
    coexist. ~10–15 min, ~3 GB scratch.

  - libkrun-sys/build.rs: optional `BOXLITE_LIBKRUNFW_DIND_PATH`
    env var picks up the dind blob at boxlite build time and stages
    it next to the lean one in the install dir. Default builds
    (env unset) are byte-identical to before — no embedded change.

  - util::configure_library_env_with_prepend: new variant that
    accepts caller-supplied LD_LIBRARY_PATH prepends. Lets per-box
    setup inject a private libs dir without rewriting the existing
    embedded-runtime / dladdr path order.

  - vmm/controller/spawn.rs::stage_dind_libkrunfw: when a box's
    BoxOptions::support_docker is true AND a dind blob was bundled
    at build time, creates `<box-dir>/libs/libkrunfw.so.5` as a
    symlink to the dind blob and prepends that dir to the shim's
    LD_LIBRARY_PATH. libkrun's dlopen("libkrunfw.so.5") then resolves
    to the fat kernel for THIS box only — without a dind blob,
    silent fallback to the lean kernel (the Phase A caps + cgroup
    still apply, just no bridge / netfilter). Per-box symlink is
    torn down together with the box on `boxlite rm`.

  - guest/container/spec.rs (Phase A finalisation): the support_docker
    path now also clears readonly_paths + masked_paths to vec![],
    overriding oci-spec's defaults. KNOWN LIMITATION: libcontainer-
    0.5.7 still applies the default /proc hardening despite our
    empty list — root cause documented in the inline comment;
    workaround is the dockerd-side bypass flags listed below.

Verified end-to-end (docker:dind image):

  - `boxlite run --support-docker --entrypoint sh -v ctx:/probe
    docker:dind /probe/probe.sh` where probe.sh starts dockerd with
    `--bridge=none --iptables=false --storage-driver=vfs` and runs
    `docker build --network=host -t boxlite-test:1 /probe/ctx`
    against `FROM alpine:3.19 / RUN echo …` → build exit 0, image
    written, runs to completion.

Default behaviour byte-identical:

  - `boxlite run alpine sh -c "grep ^CapBnd /proc/self/status"`
    returns 0xa80425fb (14 Docker defaults, lean profile) — unchanged.
  - `mount | grep cgroup` shows only the ro mount, no rw overlay.
  - `/proc/sys/net/bridge/` does not exist (lean kernel has no
    CONFIG_BRIDGE).

What's still bypass-flag territory (follow-up):

  - dockerd's default bridge / iptables setup needs `/proc/sys` writable;
    libcontainer-0.5.7 ignores our empty `readonlyPaths` and bind-
    remounts /proc/sys ro. Users must pass dockerd `--bridge=none
    --iptables=false` and use `--network=host` for build / run.
  - storage-driver auto-detection probes mount paths that may trip the
    same hardening; users pin `--storage-driver=vfs` to skip detection.
  - Together: full `docker compose up` with default bridge networks
    (issue boxlite-ai#276 acceptance) still needs the libcontainer fix.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

`make test:integration:cli` uses `cargo test -p boxlite-cli --tests`,
which only discovers integration tests under `src/cli/tests/`. The
94 binary-inline `#[cfg(test)]` unit tests in `src/cli/src/` (CLI
arg plumbing, parser helpers, ManagementFlags::apply_to, etc.) need
`--bins` to be picked up and were silently orphaned from the make
target matrix until now.

Adds:

  - `test:unit:cli` — `cargo test -p boxlite-cli --bins` (or nextest
    equivalent). Fast, no VM required. Pulls in all 94 inline tests.
  - `test:unit:core` now invokes it alongside rust + ffi so the
    full unit matrix actually covers the CLI plumbing.

Surfaced by adding the four `management_flags_*` /
`box_options_default_*` tests for the `--support-docker` flag plumbing
in the previous commits — they were passing under direct `cargo test`
but not via any `make` target.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Adds a real-VM integration test that spawns `boxlite run
--support-docker --entrypoint sh docker:dind ...` against an alpine
Dockerfile and verifies `docker build` produces a tagged image. This
is the canary for issue boxlite-ai#276's acceptance criterion (every kernel
config + userspace plumbing + per-box symlink in Phase A/B is on the
hot path).

Gated on `BOXLITE_DIND_TEST=1` because it needs a libkrunfw-dind
blob bundled at build time (`make libkrunfw-dind` + a rebuild with
`BOXLITE_LIBKRUNFW_DIND_PATH` set). Without the env var the test
prints a SKIP notice and returns — keeps the default `test:integration`
matrix runnable on hosts that haven't built the dind kernel.

New make target `test:integration:dind` sets the env and runs only
this test file. Not wired into any aggregator: explicit invocation
when validating Phase B changes or before a release that claims dind
support.

Doesn't go through `common::boxlite()` / `new_cmd()` because those
force the Chinese-mirror test registries via `apply_registries()`,
which don't reliably serve `docker:dind`. Uses the default Docker Hub
registry instead — the right config for a test that exercises Docker
itself.

Skipped assertion on `boxlite run`'s own exit code: with `--entrypoint`
the foreground exec is `sleep infinity` (artifact of attaching stdio
while the real workload runs as PID 1). When the init process exits
cleanly, the container's PID namespace tears down and the sleep gets
SIGKILL'd; boxlite then reports 137 even though the actual workload
succeeded. The probe script's `[exit=$?]` marker in result.log is the
authoritative signal — that's what we assert on. (Follow-up: foreground
exit code should follow the init process, not the foreground sleep.)

Verified locally:
  - With env var + dind blob bundled: passes in ~21s, result.log shows
    full BuildKit pipeline + `naming to docker.io/library/...:1 done`.
  - Without env var: skips with a clear message.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Add `--cmd ARG` (repeatable) under ManagementFlags so callers can pass
arguments to the image's existing ENTRYPOINT without replacing it
(Docker CMD semantics). Gated on `--support-docker`: the lean flow's
positional `[COMMAND...]` is still a secondary-exec attach, so the
gate keeps default behaviour byte-for-byte identical.

run.rs: reject `--cmd` without `--support-docker` at validate-time;
when `--cmd` is set without a positional foreground command, fall
back to `sleep infinity` so boxlite blocks on PID 1's lifetime.

Rewrite the dind integration test to pass dockerd flags via `--cmd`
and run the image's own `dockerd-entrypoint.sh` as PID 1, removing
the previous `--entrypoint sh` bypass. Probe script now waits for
the dockerd socket the entrypoint brings up instead of starting
dockerd itself.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Previously the dind regression test was opt-in (BOXLITE_DIND_TEST=1 +
manual rebuild with BOXLITE_LIBKRUNFW_DIND_PATH), so by default no run
of `make test:integration:cli` exercised dockerd-in-box and a Phase B
regression could land green. Now the make target:

* Hard-checks for target/dind-kernel/lib64/libkrunfw-dind.so.5 and
  refuses to proceed without it (one-time `make libkrunfw-dind`,
  ~10–20 min, cached after).
* Auto-exports BOXLITE_LIBKRUNFW_DIND_PATH before cargo builds so the
  embedded runtime carries both the lean and the dind blobs.

`test:integration:dind` is now a thin alias that narrows nextest's
filter to the single dind test for fast iteration.

The test itself flips from opt-in (BOXLITE_DIND_TEST=1) to opt-out
(BOXLITE_SKIP_DIND_TEST=1) — hosts that genuinely cannot run dind
(no nested virt, blocked cgroup2 mounts) still have an escape hatch,
but the default behavior is RUN so a real regression fails the suite.

Verified: `make test:integration:dind` PASS in 37.66s on a host with
the dind kernel blob pre-built.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>