lib: add missing Hare-stdlib functions (ascii/bytes/strings/path/endian)

ascii: valid, validstr, ispunct, isprint, iscntrl, isgraph, isblank,
strcasecmp.

bytes: hasprefix, hassuffix, rindex, rindexbyte, contains, reverse,
zero.

strings: rindex, sub, trimprefix, trimsuffix, ltrimbyte, rtrimbyte,
trimbyte. The byte-set trim is a single-byte subset of Hare's
`trim(input, exclude: rune...)`; no variadic ABI yet.

path: dirname, basename, extension, join. Owned-str returns where the
result isn't a borrowed view of the input (join).

endian: full Hare table — be/le get/put for u16/u32/u64 plus the
network-order htonu/ntohu pair extended to 32/64.

lib/CLAUDE.md rewritten to reflect the post-graduation policy
(tagged-union returns, owned-str returns, plan9 names, documented
deviations for non-graduating modules).

Makefile picks up lib/ascii and lib/fmt as wwdump_ww / w6c_ww deps so
lib-only edits regenerate the affected binaries.

lib/strings/strings.ww

@@ -128,3 +128,91 @@ export fn dup(s: str) str = {
 	r.len = s.len;
 	return r;
 };
+
+// rindex — last index of `sub` in `s`. Mirrors Hare's strings::rindex
+// (slice case). Empty `sub` matches at s.len.
+export fn rindex(s: str, sub: str) (i32 | void) = {
+	if (sub.len == 0) { return s.len; };
+	if (sub.len > s.len) { return; };
+	let i: i32 = s.len - sub.len;
+	for (i >= 0) {
+		let j: i32 = 0;
+		let ok: bool = true;
+		for (j < sub.len) {
+			if (s[i + j] != sub[j]) { ok = false; j = sub.len; }
+			else { j += 1; };
+		};
+		if (ok) { return i; };
+		i -= 1;
+	};
+	return;
+};
+
+// sub — borrowed substring `s[start..end]`. Mirrors Hare's
+// strings::sub. Caller must ensure 0 <= start <= end <= s.len; out-of-
+// range indices are clamped silently here, where Hare aborts.
+export fn sub(s: str, start: i32, end: i32) str = {
+	let lo: i32 = start;
+	let hi: i32 = end;
+	if (lo < 0)     { lo = 0; };
+	if (hi > s.len) { hi = s.len; };
+	if (hi < lo)    { hi = lo; };
+	let r: str;
+	r.ptr = s.ptr + (lo: u64);
+	r.len = hi - lo;
+	return r;
+};
+
+// trimprefix — `s` with `pre` stripped from the front, or `s`
+// unchanged if it doesn't start with `pre`. Returns a borrowed view.
+// Mirrors Hare's strings::trimprefix.
+export fn trimprefix(s: str, pre: str) str = {
+	if (!hasprefix(s, pre)) { return s; };
+	let r: str;
+	r.ptr = s.ptr + (pre.len: u64);
+	r.len = s.len - pre.len;
+	return r;
+};
+
+// trimsuffix — `s` with `suf` stripped from the end, or `s` unchanged
+// if it doesn't end with `suf`. Returns a borrowed view. Mirrors
+// Hare's strings::trimsuffix.
+export fn trimsuffix(s: str, suf: str) str = {
+	if (!hassuffix(s, suf)) { return s; };
+	let r: str;
+	r.ptr = s.ptr;
+	r.len = s.len - suf.len;
+	return r;
+};
+
+// ltrimbyte / rtrimbyte / trimbyte — strip occurrences of a single
+// byte from the left, right, or both ends. Returns a borrowed view.
+// Hare's strings::ltrim / rtrim / trim take a rune varargs set; ww's
+// subset takes a single byte (the common ASCII case).
+export fn ltrimbyte(s: str, c: u8) str = {
+	let i: i32 = 0;
+	for (i < s.len) {
+		if (s[i] != c) { break; };
+		i += 1;
+	};
+	let r: str;
+	r.ptr = s.ptr + (i: u64);
+	r.len = s.len - i;
+	return r;
+};
+
+export fn rtrimbyte(s: str, c: u8) str = {
+	let n: i32 = s.len;
+	for (n > 0) {
+		if (s[n - 1] != c) { break; };
+		n -= 1;
+	};
+	let r: str;
+	r.ptr = s.ptr;
+	r.len = n;
+	return r;
+};
+
+export fn trimbyte(s: str, c: u8) str = {
+	return rtrimbyte(ltrimbyte(s, c), c);
+};