lib/strings+test: port dupall from Hare

ref/hare/strings/dup.ha:26-35. Returns ([]str | nomem); duplicates
every str in the input slice via the now-graduated alloc-slice
builtin (#45 unblocked `let s: []str = alloc([], n)?`). Loop body
uses appendstr because `[]str` element is 16B and the bare `append`
builtin truncates (#11) — pre-allocated cap=s.len means rt_ensure's
grow branch never fires.

Defer-rollback omitted: with `dup()` still unchecked (graduation
tracked by #46), the only nomem source is the initial slice alloc,
so there is no partial state to roll back. Will revisit when #46
lands.

Empty-input early-return short-circuits via {nil,0,0} because
rt_alloc(0) is an mmap of 0 bytes which the kernel rejects with
-EINVAL — Hare hands back a sentinel. Localized at the call site
pending #47.

Tests assert independent allocations at every index of multi-element
inputs, including a multibyte row.

selfhost/cmd/w6c/main.combined.ww

@@ -1914,6 +1914,42 @@ export fn dup(s: str) str = {
 	return r;
 };
 
+// dupall — fresh `[]str` whose elements are independent copies of
+// `s`'s elements. Caller releases via [[freeall]].
+// ref/hare/strings/dup.ha:26 (#6).
+//
+// Hare gates the per-element dup behind `?` and rolls back via
+// `defer if (!ok) freeall(newsl)`. ww has no `defer if`; more
+// importantly, ww's [[dup]] is still unchecked (returns plain `str`,
+// aborts via os.alloc on OOM — see top-of-file divergence note),
+// so the only nomem propagation point is the initial slice alloc.
+// With no inner failure path, the rollback is structurally a no-op
+// and is omitted; it returns once dup graduates to `(str | nomem)`
+// (#46). The pre-allocated slice has `cap == s.len`, so appendstr's
+// rt_ensure call never reaches the grow branch.
+//
+// Empty input bypasses the alloc: rt_alloc(0) is an mmap of 0 bytes
+// which returns -EINVAL, and the alloc-slice `?` shortcut routes
+// that through nomem — Hare's heap allocator hands back a sentinel
+// instead (#47). Return `{nil, 0, 0}` directly so callers get the
+// Hare-observable shape (len==0, freeall is a no-op via cap==0).
+export fn dupall(s: []str) ([]str | nomem) = {
+	if (s.len == 0) {
+		let r: []str;
+		r.ptr = nil: *str;
+		r.len = 0;
+		r.cap = 0;
+		return r;
+	};
+	let newsl: []str = alloc([], s.len)?;
+	let i: i32 = 0;
+	for (i < s.len) {
+		appendstr(&newsl, dup(s[i]));
+		i += 1;
+	};
+	return newsl;
+};
+
 // freeall — release each element + the slice header. The natural
 // disposer for any `[]str` of dup'd elements (e.g. shlex.split).
 // ref/hare/strings/dup.ha:38.

selfhost/cmd/wwdump/main.combined.ww

@@ -1914,6 +1914,42 @@ export fn dup(s: str) str = {
 	return r;
 };
 
+// dupall — fresh `[]str` whose elements are independent copies of
+// `s`'s elements. Caller releases via [[freeall]].
+// ref/hare/strings/dup.ha:26 (#6).
+//
+// Hare gates the per-element dup behind `?` and rolls back via
+// `defer if (!ok) freeall(newsl)`. ww has no `defer if`; more
+// importantly, ww's [[dup]] is still unchecked (returns plain `str`,
+// aborts via os.alloc on OOM — see top-of-file divergence note),
+// so the only nomem propagation point is the initial slice alloc.
+// With no inner failure path, the rollback is structurally a no-op
+// and is omitted; it returns once dup graduates to `(str | nomem)`
+// (#46). The pre-allocated slice has `cap == s.len`, so appendstr's
+// rt_ensure call never reaches the grow branch.
+//
+// Empty input bypasses the alloc: rt_alloc(0) is an mmap of 0 bytes
+// which returns -EINVAL, and the alloc-slice `?` shortcut routes
+// that through nomem — Hare's heap allocator hands back a sentinel
+// instead (#47). Return `{nil, 0, 0}` directly so callers get the
+// Hare-observable shape (len==0, freeall is a no-op via cap==0).
+export fn dupall(s: []str) ([]str | nomem) = {
+	if (s.len == 0) {
+		let r: []str;
+		r.ptr = nil: *str;
+		r.len = 0;
+		r.cap = 0;
+		return r;
+	};
+	let newsl: []str = alloc([], s.len)?;
+	let i: i32 = 0;
+	for (i < s.len) {
+		appendstr(&newsl, dup(s[i]));
+		i += 1;
+	};
+	return newsl;
+};
+
 // freeall — release each element + the slice header. The natural
 // disposer for any `[]str` of dup'd elements (e.g. shlex.split).
 // ref/hare/strings/dup.ha:38.