build: parallelize native compile with xargs -P, not batch-and-wait (#78)

The previous loop backgrounded JOBS compiles then `wait`ed for the whole
batch before starting the next JOBS - one slow TU idles every other core
until the batch drains. Worse, a failing background zig cc under `&` was
invisible to set -e (bare `wait` returns 0 regardless of child exit
status), so a broken compile silently produced no .o and only surfaced
later as a cryptic link error.

xargs -P keeps all JOBS slots continuously saturated (no batch boundary)
and propagates a non-zero exit from any invocation, which set -e now
catches immediately.

Author: dfa1

scripts/build-zstd.sh

@@ -131,14 +131,20 @@ esac
 CFLAGS="-O3 $ARCH_FLAG -DNDEBUG -DZSTD_LEGACY_SUPPORT=4 -DXXH_NAMESPACE=ZSTD_ $VIS_FLAG \
         -I$ZSTD_LIB -I$ZSTD_LIB/common -fPIC"
 
-i=0
-for src in $SRCS; do
-    out="$WORK/$(basename "$src").o"
-    zig cc -target "$ZIG_TARGET" $CFLAGS -c "$src" -o "$out" &
-    i=$((i + 1))
-    [ $((i % JOBS)) -eq 0 ] && wait
-done
-wait
+# xargs -P keeps all $JOBS slots saturated (a fixed-size batch-then-wait loop
+# idles every other core behind the batch's slowest TU) and, unlike bare `&` +
+# `wait`, actually propagates a failing compile's exit status - xargs -P exits
+# non-zero if any invocation does, which set -e then catches. A silently
+# swallowed failed zig cc would otherwise surface only as a missing .o and a
+# cryptic link error, or worse, a link that "succeeds" with a stale .o left
+# over from a previous run.
+compile_one() {
+    zig cc -target "$ZIG_TARGET" $CFLAGS -c "$1" -o "$WORK/$(basename "$1").o"
+}
+export -f compile_one
+export ZIG_TARGET CFLAGS WORK
+
+printf '%s\n' $SRCS | xargs -P "$JOBS" -I{} bash -c 'compile_one "$@"' _ {}
 
 # Link the shared library. zstd.h marks the public API with ZSTDLIB_VISIBLE,
 # so -fvisibility=hidden keeps everything else internal.