Registra el triple de Alpine `x86_64-alpine-linux-musl` como target de rustc.

POR QUÉ (SDD 31 §4.bis). El build usa el triple de Alpine en todas partes porque el stage0 es el
rustc del LAB y Alpine RENOMBRA su triple: con el canónico, el stage0 no tiene la std
(`can't find crate for std`). Pero ese nombre lo conoce el rustc de Alpine y NO el de upstream, así
que en el stage 2 —cuando toma el relevo el compilador que acabamos de construir— el build muere:

    error: error loading target specification: could not find specification for target
           "x86_64-alpine-linux-musl"

O sea: el triple que hace falta para ARRANCAR el build es el que el PRODUCTO del build no tiene.
Esto lo mete DENTRO del compilador, que es lo que hace Alpine en su APKBUILD, y por eso vale en
todos los stages (un `.json` por `RUST_TARGET_PATH` no sirve para el triple del HOST).

La única diferencia real con el spec canónico es `crt_static_default = false`: es lo que habilita
dylibs y, con ellos, los PROC-MACROS. Un rustc con `crt-static` por default no puede compilar
`serde_derive` ni `clap_derive` — ni las 44 recetas `cargo-*` del corpus que usan `derive`.

--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/x86_64_alpine_linux_musl.rs
@@ -0,0 +1,37 @@
+use crate::spec::{
+    Arch, Cc, LinkerFlavor, Lld, SanitizerSet, StackProbeType, Target, TargetMetadata, base,
+};
+
+pub(crate) fn target() -> Target {
+    let mut base = base::linux_musl::opts();
+    base.cpu = "x86-64".into();
+    base.plt_by_default = false;
+    base.max_atomic_width = Some(64);
+    base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-m64"]);
+    base.stack_probes = StackProbeType::Inline;
+    base.static_position_independent_executables = true;
+    base.supported_sanitizers = SanitizerSet::ADDRESS
+        | SanitizerSet::CFI
+        | SanitizerSet::LEAK
+        | SanitizerSet::MEMORY
+        | SanitizerSet::THREAD;
+    base.supports_xray = true;
+    // A DIFERENCIA del spec canónico, que lo deja en `true`: sin esto no hay dylibs, y sin dylibs
+    // no hay proc-macros. Es el mismo valor que usa Alpine en su rustc.
+    base.crt_static_default = false;
+
+    Target {
+        llvm_target: "x86_64-alpine-linux-musl".into(),
+        metadata: TargetMetadata {
+            description: Some("64-bit Alpine Linux with musl (triple propio de Alpine)".into()),
+            tier: Some(3),
+            host_tools: Some(true),
+            std: Some(true),
+        },
+        pointer_width: 64,
+        data_layout:
+            "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128".into(),
+        arch: Arch::X86_64,
+        options: base,
+    }
+}
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1506,6 +1506,7 @@
     ("aarch64-unknown-linux-musl", aarch64_unknown_linux_musl),
     ("aarch64_be-unknown-linux-musl", aarch64_be_unknown_linux_musl),
     ("x86_64-unknown-linux-musl", x86_64_unknown_linux_musl),
+    ("x86_64-alpine-linux-musl", x86_64_alpine_linux_musl),
     ("i686-unknown-linux-musl", i686_unknown_linux_musl),
     ("i586-unknown-linux-musl", i586_unknown_linux_musl),
     ("mips-unknown-linux-musl", mips_unknown_linux_musl),