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

@@ -1,9 +1,138 @@
-// endian — byte-order conversions. Subset of Hare's endian::; only
-// the network-order helpers we need for net::. Host order on amd64 is
-// little-endian, so hton* / ntoh* are byte swaps.
+// endian — byte-order conversions. Mirrors Hare's endian:: surface:
+// big-endian (be*), little-endian (le*), and network-order (hton/ntoh)
+// helpers. Host order on amd64 is little-endian, so hton/ntoh are
+// byte swaps and the le* family is identity.
+
+// ---- network order (host ↔ big-endian, since amd64 is LE) -----------
 
 export fn htonu16(in: u16) u16 = {
-	return ((in << 8) | (in >> 8)) & 0xffff;
+	return ((in << 8u16) | (in >> 8u16)) & 0xffffu16;
+};
+export fn ntohu16(in: u16) u16 = { return htonu16(in); };
+
+export fn htonu32(in: u32) u32 = {
+	let b0: u32 = (in >> 24u32) & 0xffu32;
+	let b1: u32 = (in >> 16u32) & 0xffu32;
+	let b2: u32 = (in >> 8u32)  & 0xffu32;
+	let b3: u32 =  in           & 0xffu32;
+	return (b3 << 24u32) | (b2 << 16u32) | (b1 << 8u32) | b0;
+};
+export fn ntohu32(in: u32) u32 = { return htonu32(in); };
+
+export fn htonu64(in: u64) u64 = {
+	let b0: u64 = (in >> 56u64) & 0xffu64;
+	let b1: u64 = (in >> 48u64) & 0xffu64;
+	let b2: u64 = (in >> 40u64) & 0xffu64;
+	let b3: u64 = (in >> 32u64) & 0xffu64;
+	let b4: u64 = (in >> 24u64) & 0xffu64;
+	let b5: u64 = (in >> 16u64) & 0xffu64;
+	let b6: u64 = (in >> 8u64)  & 0xffu64;
+	let b7: u64 =  in           & 0xffu64;
+	return (b7 << 56u64) | (b6 << 48u64) | (b5 << 40u64) | (b4 << 32u64)
+	     | (b3 << 24u64) | (b2 << 16u64) | (b1 << 8u64)  | b0;
+};
+export fn ntohu64(in: u64) u64 = { return htonu64(in); };
+
+// ---- big-endian byte get/put on a slice ------------------------------
+
+export fn begetu16(buf: []u8) u16 = {
+	let b0: u16 = buf[0]: u16;
+	let b1: u16 = buf[1]: u16;
+	return (b0 << 8u16) | b1;
 };
 
-export fn ntohu16(in: u16) u16 = htonu16(in);
+export fn beputu16(buf: []u8, in: u16) void = {
+	buf[0] = ((in >> 8u16) & 0xffu16): u8;
+	buf[1] = (in & 0xffu16): u8;
+};
+
+export fn begetu32(buf: []u8) u32 = {
+	let b0: u32 = buf[0]: u32;
+	let b1: u32 = buf[1]: u32;
+	let b2: u32 = buf[2]: u32;
+	let b3: u32 = buf[3]: u32;
+	return (b0 << 24u32) | (b1 << 16u32) | (b2 << 8u32) | b3;
+};
+
+export fn beputu32(buf: []u8, in: u32) void = {
+	buf[0] = ((in >> 24u32) & 0xffu32): u8;
+	buf[1] = ((in >> 16u32) & 0xffu32): u8;
+	buf[2] = ((in >> 8u32)  & 0xffu32): u8;
+	buf[3] = (in            & 0xffu32): u8;
+};
+
+export fn begetu64(buf: []u8) u64 = {
+	let b0: u64 = buf[0]: u64;
+	let b1: u64 = buf[1]: u64;
+	let b2: u64 = buf[2]: u64;
+	let b3: u64 = buf[3]: u64;
+	let b4: u64 = buf[4]: u64;
+	let b5: u64 = buf[5]: u64;
+	let b6: u64 = buf[6]: u64;
+	let b7: u64 = buf[7]: u64;
+	return (b0 << 56u64) | (b1 << 48u64) | (b2 << 40u64) | (b3 << 32u64)
+	     | (b4 << 24u64) | (b5 << 16u64) | (b6 << 8u64)  | b7;
+};
+
+export fn beputu64(buf: []u8, in: u64) void = {
+	buf[0] = ((in >> 56u64) & 0xffu64): u8;
+	buf[1] = ((in >> 48u64) & 0xffu64): u8;
+	buf[2] = ((in >> 40u64) & 0xffu64): u8;
+	buf[3] = ((in >> 32u64) & 0xffu64): u8;
+	buf[4] = ((in >> 24u64) & 0xffu64): u8;
+	buf[5] = ((in >> 16u64) & 0xffu64): u8;
+	buf[6] = ((in >> 8u64)  & 0xffu64): u8;
+	buf[7] = (in            & 0xffu64): u8;
+};
+
+// ---- little-endian byte get/put on a slice ---------------------------
+
+export fn legetu16(buf: []u8) u16 = {
+	let b0: u16 = buf[0]: u16;
+	let b1: u16 = buf[1]: u16;
+	return (b1 << 8u16) | b0;
+};
+
+export fn leputu16(buf: []u8, in: u16) void = {
+	buf[0] = (in & 0xffu16): u8;
+	buf[1] = ((in >> 8u16) & 0xffu16): u8;
+};
+
+export fn legetu32(buf: []u8) u32 = {
+	let b0: u32 = buf[0]: u32;
+	let b1: u32 = buf[1]: u32;
+	let b2: u32 = buf[2]: u32;
+	let b3: u32 = buf[3]: u32;
+	return (b3 << 24u32) | (b2 << 16u32) | (b1 << 8u32) | b0;
+};
+
+export fn leputu32(buf: []u8, in: u32) void = {
+	buf[0] = (in            & 0xffu32): u8;
+	buf[1] = ((in >> 8u32)  & 0xffu32): u8;
+	buf[2] = ((in >> 16u32) & 0xffu32): u8;
+	buf[3] = ((in >> 24u32) & 0xffu32): u8;
+};
+
+export fn legetu64(buf: []u8) u64 = {
+	let b0: u64 = buf[0]: u64;
+	let b1: u64 = buf[1]: u64;
+	let b2: u64 = buf[2]: u64;
+	let b3: u64 = buf[3]: u64;
+	let b4: u64 = buf[4]: u64;
+	let b5: u64 = buf[5]: u64;
+	let b6: u64 = buf[6]: u64;
+	let b7: u64 = buf[7]: u64;
+	return (b7 << 56u64) | (b6 << 48u64) | (b5 << 40u64) | (b4 << 32u64)
+	     | (b3 << 24u64) | (b2 << 16u64) | (b1 << 8u64)  | b0;
+};
+
+export fn leputu64(buf: []u8, in: u64) void = {
+	buf[0] = (in            & 0xffu64): u8;
+	buf[1] = ((in >> 8u64)  & 0xffu64): u8;
+	buf[2] = ((in >> 16u64) & 0xffu64): u8;
+	buf[3] = ((in >> 24u64) & 0xffu64): u8;
+	buf[4] = ((in >> 32u64) & 0xffu64): u8;
+	buf[5] = ((in >> 40u64) & 0xffu64): u8;
+	buf[6] = ((in >> 48u64) & 0xffu64): u8;
+	buf[7] = ((in >> 56u64) & 0xffu64): u8;
+};