feat: native linux-x64-glibc module packages and reviewed license supplements (ADR 0049, ADR 0052)

Implements ADR 0049's deferred native target and ADR 0052's reviewed
license supplements. The proof case is a real module using sharp.
packageFormat stays 1, and `any` is unchanged.

Packager (@ekklesia/module-pack):
- --target linux-x64-glibc. Native or platform-specific packages, found by
  the same generic rule that refuses them in `any`, stay outside the bundle.
- Each native package's production closure is walked through its own
  dependencies, installed optionalDependencies that match the target, and
  required peers. It is copied as real files flat under node_modules/<name>,
  with no links, dev dependencies, declarations, source maps, or other
  platforms' packages. Missing or foreign-platform required dependencies,
  version conflicts, links, foreign machines, and Node.js range conflicts
  fail closed.
- runtime.nodeApi, nodeAbi, and libcVersion are read from the binaries by a
  small ELF reader: the addon's node_api_module_get_api_version_v1 and the
  newest GLIBC_ symbol version needed. No shelling out. A native target with
  no addon is refused.
- ADR 0052 supplements: package-provided material stays primary. An exact
  match on name, version, and ekklesia-content-v1 digest (sorted normalized
  paths with each file's size and SHA-256; no metadata) adds labelled
  material after the package's own. Any mismatch, a declared-licence
  conflict, or a malformed or unreviewed supplement file fails. Missing
  material with no supplement still fails.

Supplement for @img/[email protected]:
- 184 components and 143 unique texts, assembled from the exact upstream
  sources sharp-libvips v1.3.3 builds linux-x64 from: 27 C/C++ libraries,
  glib's gvdb, librsvg's Rust crates (reproduced with cargo tree), the Rust
  standard library at the rustc commit recorded in the binary, plus the
  LGPL-3.0, GPL-3.0, and MPL-2.0 texts. Each source is recorded with its
  SHA-256 in PROVENANCE.md.
- It pins digest ekklesia-content-v1:sha256:50647b0b…, which is identical
  from the installed copy and from the registry tarball.
- LGPL/MPL source-availability determinations stay open, as ADR 0052
  states. Nothing claims they are met.

Verifier (Core):
- linux-x64-glibc is accepted only on a host whose platform, arch, glibc
  family and version, and Node-API version (from Node itself) match.
- Every ELF file must be x86-64; every .node must be an ELF object.
- `any` packages now also refuse node_modules/ and ELF files.
- Contract: native metadata must state nodeApi or nodeAbi, and Linux targets
  libcVersion (ADR 0049).

Proof:
- A checked-in AGPL native fixture packs byte-identically from unrelated
  copies (8.86 MB) and verifies with Core's verifier.
- Extracted elsewhere, it runs a sharp resize and PNG round trip in an
  empty-environment process. Every resolution stays in the package, and
  only the package's addon and libvips plus host system libraries load.

Signage is untouched.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

packages/module-pack/tests/support/fixture-module.ts

@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, realpath, rm, symlink, writeFile } from "node:fs/promises";
+import { cp, mkdir, mkdtemp, realpath, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -223,3 +223,38 @@ export async function fixtureModule(options: FixtureModuleOptions = {}): Promise
 }
 
 export const SOURCE_REVISION = "86ae907f59458508e3277666cdd214f5bd7c1078";
+
+const nativeFixtureSource = path.join(packageRoot, "tests", "fixtures", "native-module");
+
+/**
+ * The checked-in native proof module (`tests/fixtures/native-module`), copied to a fresh, unrelated
+ * temporary directory with `node_modules` linking the real sharp and Module SDK this package's
+ * workspace installed, as a module's own install would provide them.
+ */
+export async function nativeFixtureModule(): Promise<string> {
+  // Inside this package, beside its own node_modules, as a module checkout sits beside its own: a
+  // bundle's module keys are paths relative to the module, so a copy in the system temporary
+  // directory would bundle paths that climb out of it and into this checkout.
+  const fixtures = path.join(packageRoot, ".fixtures");
+  await mkdir(fixtures, { recursive: true });
+  const root = await realpath(await mkdtemp(path.join(fixtures, "native-")));
+  temporaryDirectories.push(root);
+  const moduleDirectory = path.join(root, "native-proof");
+  await cp(nativeFixtureSource, moduleDirectory, { recursive: true });
+  const modules = path.join(moduleDirectory, "node_modules");
+  await mkdir(path.join(modules, "@ekklesia"), { recursive: true });
+  await symlink(
+    await realpath(path.join(packageRoot, "node_modules", "sharp")),
+    path.join(modules, "sharp"),
+  );
+  await symlink(
+    await realpath(path.join(packageRoot, "node_modules", "@ekklesia", "module-sdk")),
+    path.join(modules, "@ekklesia", "module-sdk"),
+  );
+  return moduleDirectory;
+}
+
+/** The workspace's real installed package, for tests that build fake native packages from it. */
+export async function installedPackageFile(...segments: string[]): Promise<string> {
+  return realpath(path.join(packageRoot, "node_modules", ...segments));
+}