w6c+wcc+selfhost+lib: int-cast truncate + use_alias, 5 new modules

Two cgen/check bugs surfaced by new lib modules, plus the modules
themselves (crc64, siphash, random, base64, base32).

  1. `(big_u64): u32` (and `: u16`, `: u8`, `: bool`) didn't truncate.
     N_CAST emitted nothing for int↔int; the value stayed in AX with
     its upper bits intact and downstream CMPQ/DIVQ misread the slot.
     The TK_TILDE path already had clamp logic for the same reason —
     N_CAST was the missing case. Both stages now MOVL r,r for u32 and
     ANDQ $mask for u8/u16/bool. Signed-narrow (i8/i16/i32) stays
     no-op until w6a grows reg-reg MOVSBQ/MOVSWQ/MOVSXD. selfhost
     cgcast walks alias chains via aliaslookup before checking
     primsize/typenameisunsigned so `(u: random)` where
     `type random = u64` still bypasses the clamp.
     See cmd/w6c/cgen.c N_CAST and selfhost/cmd/wcc/cgenexpr.ww cgcast.

  2. `mod.mod` type refs (`random.random` when the imported module
     declares `export type random = u64;`) failed with "unknown type".
     The driver concatenates imports into one flat scope, so SK_USE
     `random` collided with SK_TYPE `random` and scope_define silently
     dropped the use. resolve_typename's leaf lookup required
     `kind == SK_USE` and gave up. Adds a `use_alias` flag to Sym; the
     pass-1 decl scan now marks colliding syms in both directions
     (use-after-type and type-after-use). resolve_typename and the
     N_DOT cexpr branch treat `use_alias` like SK_USE for qualified
     lookup. selfhost check.ww was already lenient on this path so no
     ww-side change was needed; bootstrap fixed point (990-995) holds.
     See cmd/wcc/check.c installdecl pass + N_DOT/resolve_typename and
     cmd/wcc/ww.h Sym.use_alias.

New modules under lib/, each with @test vectors in *_test.ww and wired
into test/wcc/900_stdlib.c (26 modules → all compile):

  - lib/hash/crc64       ECMA, ISO  (mirror of crc32 shape)
  - lib/hash/siphash     SipHash-2-4, buffer-based sum/sum24
  - lib/math/random      SplitMix64 (init, next, u32n, u64n)
  - lib/encoding/base64  RFC 4648 std + url-safe encode/decode + sizes
  - lib/encoding/base32  RFC 4648 std + base32hex encode/decode + sizes

lib/math/random/random_test.ww

@@ -0,0 +1,61 @@
+use random;
+
+@test fn seq() void = {
+	let r: random.random = random.init(1234567u64);
+	if (random.next(&r) != 6457827717110365317u64)  { let _: i32 = 1/0; };
+	if (random.next(&r) != 3203168211198807973u64)  { let _: i32 = 1/0; };
+	if (random.next(&r) != 9817491932198370423u64)  { let _: i32 = 1/0; };
+	if (random.next(&r) != 4593380528125082431u64)  { let _: i32 = 1/0; };
+	if (random.next(&r) != 16408922859458223821u64) { let _: i32 = 1/0; };
+};
+
+@test fn deterministic() void = {
+	let a: random.random = random.init(42u64);
+	let b: random.random = random.init(42u64);
+	let i: i32 = 0;
+	for (i < 32) {
+		if (random.next(&a) != random.next(&b)) { let _: i32 = 1/0; };
+		i += 1;
+	};
+};
+
+@test fn u32n_inrange() void = {
+	let r: random.random = random.init(7u64);
+	let i: i32 = 0;
+	for (i < 200) {
+		let v: u32 = random.u32n(&r, 17u32);
+		// v stored as u64 with possible high bits — mask before compare.
+		let vv: u64 = (v: u64) & 0xFFFFFFFFu64;
+		if (vv >= 17u64) { let _: i32 = 1/0; };
+		i += 1;
+	};
+};
+
+@test fn u64n_pow2() void = {
+	let r: random.random = random.init(99u64);
+	let i: i32 = 0;
+	for (i < 200) {
+		let v: u64 = random.u64n(&r, 16u64);
+		if (v >= 16u64) { let _: i32 = 1/0; };
+		i += 1;
+	};
+};
+
+@test fn u64n_nonpow2() void = {
+	let r: random.random = random.init(123u64);
+	let i: i32 = 0;
+	for (i < 200) {
+		let v: u64 = random.u64n(&r, 100u64);
+		if (v >= 100u64) { let _: i32 = 1/0; };
+		i += 1;
+	};
+};
+
+export fn main() i32 = {
+	seq();
+	deterministic();
+	u32n_inrange();
+	u64n_pow2();
+	u64n_nonpow2();
+	return 0;
+};