Phase 3: banger kernel import bridges make-*-kernel.sh output

`banger kernel import <name> --from <dir>` copies a staged kernel
bundle into the local catalog. <dir> is the output of
`make void-kernel` or `make alpine-kernel` (build/manual/void-kernel/
or build/manual/alpine-kernel/).

kernelcat.DiscoverPaths locates artifacts under <dir>:
 1. Prefers metadata.json (written by make-void-kernel.sh).
 2. Falls back to globbing: boot/vmlinux-* or vmlinuz-* (Alpine
    fallback), boot/initramfs-*, lib/modules/<latest>.

The daemon's KernelImport copies kernel + optional initrd via
system.CopyFilePreferClone and modules via system.CopyDirContents
(no-sudo mode — catalog lives under ~/.local/state), computes SHA256
over the kernel, and writes the manifest via kernelcat.WriteLocal.

While wiring this up, fixed a latent bug in system.CopyDirContents:
filepath.Join(sourceDir, ".") silently drops the trailing dot, so
`cp -a source source/contents target/` was copying the whole source
directory (including its basename) instead of just its contents.
Replaced the join with a manual "/." suffix. imagemgr.StageBootArtifacts
(the only existing caller) silently benefits.

scripts/register-void-image.sh and scripts/register-alpine-image.sh
are rewritten to use `banger kernel import … && banger image register
--kernel-ref …` instead of the find-and-pass-paths dance. Preserves
the same user-facing commands and env vars.

Tests cover: metadata.json preference, glob fallback, Alpine vmlinuz
fallback, kernel-missing error, round-trip copy into the catalog, and
the --from required flag.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

internal/daemon/kernels_test.go

@@ -12,6 +12,7 @@ import (
 	"banger/internal/kernelcat"
 	"banger/internal/paths"
 	"banger/internal/rpc"
+	"banger/internal/system"
 )
 
 func seedKernelEntry(t *testing.T, kernelsDir, name string) {
@@ -149,6 +150,72 @@ func TestRegisterImageRejectsKernelRefAndPath(t *testing.T) {
 	}
 }
 
+func TestKernelImportCopiesArtifactsAndWritesManifest(t *testing.T) {
+	src := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(src, "boot"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(src, "boot", "vmlinux-6.12.79_1"), []byte("kernel-bytes"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(src, "boot", "initramfs-6.12.79_1"), []byte("initrd-bytes"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	modulesSource := filepath.Join(src, "lib", "modules", "6.12.79_1")
+	if err := os.MkdirAll(modulesSource, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(modulesSource, "modules.dep"), []byte(""), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	kernelsDir := t.TempDir()
+	d := &Daemon{
+		layout: paths.Layout{KernelsDir: kernelsDir},
+		runner: system.NewRunner(),
+	}
+
+	entry, err := d.KernelImport(context.Background(), api.KernelImportParams{
+		Name:    "void-6.12",
+		FromDir: src,
+		Distro:  "void",
+		Arch:    "x86_64",
+	})
+	if err != nil {
+		t.Fatalf("KernelImport: %v", err)
+	}
+	if entry.Name != "void-6.12" || entry.Distro != "void" || entry.Arch != "x86_64" {
+		t.Fatalf("entry metadata = %+v", entry)
+	}
+	if entry.KernelVersion != "6.12.79_1" {
+		t.Errorf("KernelVersion = %q, want 6.12.79_1 (from modules dir)", entry.KernelVersion)
+	}
+	if entry.SHA256 == "" {
+		t.Errorf("SHA256 not populated")
+	}
+
+	if _, err := os.Stat(filepath.Join(kernelsDir, "void-6.12", "vmlinux")); err != nil {
+		t.Errorf("kernel not copied: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(kernelsDir, "void-6.12", "initrd.img")); err != nil {
+		t.Errorf("initrd not copied: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(kernelsDir, "void-6.12", "modules", "modules.dep")); err != nil {
+		t.Errorf("modules not copied: %v", err)
+	}
+}
+
+func TestKernelImportRejectsMissingFromDir(t *testing.T) {
+	d := &Daemon{
+		layout: paths.Layout{KernelsDir: t.TempDir()},
+		runner: system.NewRunner(),
+	}
+	_, err := d.KernelImport(context.Background(), api.KernelImportParams{Name: "x"})
+	if err == nil || !strings.Contains(err.Error(), "--from") {
+		t.Fatalf("KernelImport without --from: err=%v", err)
+	}
+}
+
 func TestRegisterImageMissingKernelRef(t *testing.T) {
 	rootfs := filepath.Join(t.TempDir(), "rootfs.ext4")
 	if err := os.WriteFile(rootfs, []byte("rootfs"), 0o644); err != nil {