Etapa G: tanda C tier-2 construye+corre — 6 al corpus (45->51) + wrap abuild local

BUILD-YIELD C MEDIDO (no especulacion): 6/8 de la tanda construyen+corren como ELF
estatico musl. Promovidos: file 5.47, gawk 5.3.2, gzip 1.14, tar 1.35, tree 2.3.2,
which 2.23 (+ sus parches musl de Alpine).

Texture honesta del tier-2 C (la friccion que el tier-1 Rust no tiene):
- gawk/tar/tree/which: zig-cc directo, sin tocar nada.
- file: zig-cc MISCOMPILA -> el `file` recien hecho segfaultea generando magic.mgc
  (mismo sintoma que binutils). Escape compiler="gcc" -> construye.
- gzip: (1) configure "C compiler cannot create executables" con zig-cc -> compiler="gcc";
  (2) luego el install fallaba por `local i;` de la package() de Alpine.
- jq (oniguruma), sed (perl): NO build-friction sino dep faltante en el corpus
  (completitud) -> quedan pendientes hasta importar esas libs.

Fix generico que destrabo gzip (y futuros): el importador Alpine ENVUELVE el cuerpo de
build()/package() en una funcion shell. abuild los corre COMO funciones (donde `local`
es valido); el lab corre la fase plana bajo sh -c, donde `local` fuera de funcion es
error. Envolver restaura el contexto de abuild sin tocar el sandbox ni las fases planas
del corpus (solo lo importado). test translate_wraps_body_in_function_for_local.

Confirmado: los 6 binarios corren (--version). file/gzip llevan compiler="gcc" en su
receta (escape declarativo, gueto conocido).

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

crates/hammer-cli/src/alpine_import.rs

@@ -260,13 +260,20 @@ fn func_body(text: &str, name: &str) -> Option<String> {
 /// NO toca `$CBUILD/$CHOST/$srcdir/$builddir` ni `--shared`. `$CBUILD/$CHOST` los RESUELVE el lab en
 /// runtime (env con el triple nativo saneado, Etapa G Fase 3 — `hammer-build`); `$srcdir/$builddir` y
 /// `--shared` quedan para el humano. `make DESTDIR="$pkgdir"` → `make DESTDIR="/out"`.
+///
+/// Además ENVUELVE el cuerpo en una función shell: abuild ejecuta `build()/package()` COMO funciones,
+/// donde `local i; …` es válido; el lab corre la fase bajo `sh -c "<cuerpo>"` plano, donde `local`
+/// fuera de función es error (rompía gzip al instalar). Envolver restaura el contexto de abuild sin
+/// tocar el sandbox ni las fases planas escritas a mano del corpus (sólo se envuelve lo importado).
 fn translate_abuild(body: &str, name: &str, version: &str) -> String {
-    body.replace("${pkgdir}", "/out")
+    let subst = body
+        .replace("${pkgdir}", "/out")
         .replace("$pkgdir", "/out")
         .replace("${pkgname}", name)
         .replace("$pkgname", name)
         .replace("${pkgver}", version)
-        .replace("$pkgver", version)
+        .replace("$pkgver", version);
+    format!("_abuild_phase() {{\n{subst}\n}}\n_abuild_phase")
 }
 
 /// Primer hash de un bloque `sha512sums="<hash>  <fichero>\n..."`.
@@ -348,6 +355,16 @@ package() {
         assert!(!t.contains("$pkg"));
     }
 
+    #[test]
+    fn translate_wraps_body_in_function_for_local() {
+        // abuild package() usa `local i;` (válido en función); el lab corre la fase plana ⇒ hay que
+        // envolverla o `local` rompe (gzip). El cuerpo queda DENTRO de la función, invocada al final.
+        let t = translate_abuild("local i; for i in a b; do mv $i /out/; done", "p", "1");
+        assert!(t.starts_with("_abuild_phase() {"), "{t}");
+        assert!(t.trim_end().ends_with("_abuild_phase"), "se invoca al final: {t}");
+        assert!(t.contains("local i;"), "el `local` se preserva dentro de la función: {t}");
+    }
+
     #[test]
     fn no_patches_is_empty() {
         let apk = "pkgname=zlib\npkgver=1.3\nsource=\"https://zlib.net/zlib-$pkgver.tar.gz\"\nsha512sums=\"x  z\"\n";