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/path/path.ww

@@ -1,8 +1,140 @@
 // path — filesystem path manipulation. UTF-8 paths, '/' separator.
-// Mirrors Hare's path:: surface. Reverse byte search lives in strings
-// (strings::rbyteindex), not here.
+// Mirrors Hare's path:: surface. ww doesn't yet ship the stack-buffer
+// path::buffer; the functions here all take a `str` and return a
+// borrowed view (basename / dirname) or a fresh owned str (join).
 
+use os;
+
+def SEP: u8 = 47u8;	// '/'
+
+// abs — `p` is an absolute path (starts with '/').
 export fn abs(p: str) bool = {
 	if (p.len == 0) { return false; };
-	return p[0] == ('/': u8);
+	return p[0] == SEP;
+};
+
+// dirname — directory component of `p`, POSIX-style. Returns a
+// borrowed view of `p` (or the static "." / "/" strings). Mirrors
+// Hare's path::dirname.
+export fn dirname(p: str) str = {
+	if (p.len == 0) { return "."; };
+	// Strip trailing separators.
+	let n: i32 = p.len;
+	for (n > 0) {
+		if (p[n - 1] != SEP) { break; };
+		n -= 1;
+	};
+	if (n == 0) { return "/"; };
+	// Last separator in the trimmed prefix.
+	let i: i32 = n - 1;
+	for (i >= 0) {
+		if (p[i] == SEP) { break; };
+		i -= 1;
+	};
+	if (i < 0) { return "."; };
+	// Strip trailing separators on the directory part too.
+	for (i > 0) {
+		if (p[i - 1] != SEP) { break; };
+		i -= 1;
+	};
+	if (i == 0) { return "/"; };
+	let r: str;
+	r.ptr = p.ptr;
+	r.len = i;
+	return r;
+};
+
+// basename — final path component of `p`, POSIX-style. Returns a
+// borrowed view of `p` (or "." / "/" sentinel strings). Mirrors
+// Hare's path::basename.
+export fn basename(p: str) str = {
+	if (p.len == 0) { return "."; };
+	let n: i32 = p.len;
+	for (n > 0) {
+		if (p[n - 1] != SEP) { break; };
+		n -= 1;
+	};
+	if (n == 0) { return "/"; };
+	let i: i32 = n - 1;
+	for (i >= 0) {
+		if (p[i] == SEP) { break; };
+		i -= 1;
+	};
+	let r: str;
+	r.ptr = p.ptr + ((i + 1): u64);
+	r.len = n - (i + 1);
+	return r;
+};
+
+// extension — the final ".ext" suffix of `basename(p)`, including
+// the dot, or "" if none. Returns a borrowed view of `p`. Mirrors
+// Hare's path::extension.
+export fn extension(p: str) str = {
+	let b: str = basename(p);
+	let i: i32 = b.len - 1;
+	for (i > 0) {
+		if (b[i] == 46u8) {	// '.'
+			let r: str;
+			r.ptr = b.ptr + (i: u64);
+			r.len = b.len - i;
+			return r;
+		};
+		i -= 1;
+	};
+	let empty: str;
+	empty.ptr = nil;
+	empty.len = 0;
+	return empty;
+};
+
+// join — concatenate two path components with a single '/' separator.
+// Returns owned str (release via os.free). If `b` is absolute, the
+// result is `b`. Mirrors Hare's path::buffer init+push, narrowed to
+// two-arg join (no variadic).
+export fn join(a: str, b: str) str = {
+	if (abs(b)) {
+		let buf: *u8 = os.alloc(b.len: u64): *u8;
+		let i: i32 = 0;
+		for (i < b.len) { buf[i] = b[i]; i += 1; };
+		let r: str;
+		r.ptr = buf;
+		r.len = b.len;
+		return r;
+	};
+	if (a.len == 0) {
+		let buf: *u8 = os.alloc(b.len: u64): *u8;
+		let i: i32 = 0;
+		for (i < b.len) { buf[i] = b[i]; i += 1; };
+		let r: str;
+		r.ptr = buf;
+		r.len = b.len;
+		return r;
+	};
+	if (b.len == 0) {
+		let buf: *u8 = os.alloc(a.len: u64): *u8;
+		let i: i32 = 0;
+		for (i < a.len) { buf[i] = a[i]; i += 1; };
+		let r: str;
+		r.ptr = buf;
+		r.len = a.len;
+		return r;
+	};
+	// Trim trailing '/' from a; b never starts with '/' here (checked
+	// above via abs(b)).
+	let an: i32 = a.len;
+	for (an > 0) {
+		if (a[an - 1] != SEP) { break; };
+		an -= 1;
+	};
+	let total: i32 = an + 1 + b.len;
+	let buf: *u8 = os.alloc(total: u64): *u8;
+	let i: i32 = 0;
+	for (i < an) { buf[i] = a[i]; i += 1; };
+	buf[an] = SEP;
+	let j: i32 = 0;
+	for (j < b.len) { buf[an + 1 + j] = b[j]; j += 1; };
+	let r: str;
+	r.ptr = buf;
+	r.len = total;
+	return r;
 };