lib: banner purge + WHY-only comment sweep (rule 8)

Every // ---- section banner dies (132 -> 0): names carry the WHAT.
Narration deleted (filename restatements, run-with lines, what-the-
next-line-does); every ref/hare cite, task cite, divergence, ABI/
layout contract, and ownership qualifier kept (borrowed-view lines
restored where the sweep over-cut). Comment-only proven: all 442
walk-workdir .s and 32 import-probe .s byte-identical before/after;
libbyteid 56-roster all-ID.

lib/math/floats.ww

@@ -1,6 +1,4 @@
-// floats — f64 classification, sign, bit-reinterpret core, and the f64
-// decompose half (subnormal-normalize + frexp). Ported from
-// ref/hare/math/floats.ha (fold-1: classify/sign/bits; fold-2a:
+// Ported from ref/hare/math/floats.ha (fold-1: classify/sign/bits; fold-2a:
 // issubnormalf64/normalizef64/frexpf64; strconv-foundation fold-1a:
 // F32 bit-layout + f32bits/f32frombits + floatinfo struct type;
 // fold-1b: NAN_BITS/INF_BITS sentinels; γ-cleanup: f64info/f32info
@@ -12,7 +10,6 @@
 
 package math;
 
-// Returns the binary representation of the given f64.
 // ref/hare/math/floats.ha:5. Parens around &n are load-bearing: ww's `:`
 // cast binds tighter than unary `&`, so Hare's `*(&n: *u64)` would parse
 // as `*(&(n: *u64))`; `(&n): *u64` reinterprets the address as intended.
@@ -20,19 +17,16 @@ export fn f64bits(n: f64) u64 = {
 	return *((&n): *u64);
 };
 
-// Returns the binary representation of the given f32.
 // ref/hare/math/floats.ha:8
 export fn f32bits(n: f32) u32 = {
 	return *((&n): *u32);
 };
 
-// Returns f64 with the given binary representation.
 // ref/hare/math/floats.ha:11
 export fn f64frombits(n: u64) f64 = {
 	return *((&n): *f64);
 };
 
-// Returns f32 with the given binary representation.
 // ref/hare/math/floats.ha:14
 export fn f32frombits(n: u32) f32 = {
 	return *((&n): *f32);
@@ -45,25 +39,20 @@ export fn f32frombits(n: u32) f32 = {
 // amounts and mask widths, so they are typed u64 here — the closest
 // stand-in for Hare's untyped-int adapt at those use sites.
 
-// The number of bits in the significand of the binary representation of f64.
 export def F64_MANTISSA_BITS: u64 = 52;
 
-// The number of bits in the exponent of the binary representation of f64.
 export def F64_EXPONENT_BITS: u64 = 11;
 
 // The bias of the exponent of the binary representation of f64. Subtract this
 // from the exponent in the binary representation to get the actual exponent.
 export def F64_EXPONENT_BIAS: u64 = 1023;
 
-// Mask with each bit of an f64's mantissa set.
 // ref/hare/math/floats.ha:37
 export def F64_MANTISSA_MASK: u64 = (1 << F64_MANTISSA_BITS) - 1;
 
-// Mask with each bit of an f64's exponent set.
 // ref/hare/math/floats.ha:40
 export def F64_EXPONENT_MASK: u64 = (1 << F64_EXPONENT_BITS) - 1;
 
-// The mask that gets an f64's sign.
 // ref/hare/math/floats.ha:75
 def F64_SIGN_MASK: u64 = 1u64 << 63;
 
@@ -84,11 +73,9 @@ def F64_EXP_ZERO: u64 = (F64_EXPONENT_BIAS - 1) << F64_MANTISSA_BITS;
 // the u32 bit container, the same way the F64 family rides u64 — see
 // the note above F64_MANTISSA_BITS).
 
-// The number of bits in the significand of the binary representation of f32.
 // ref/hare/math/floats.ha:27
 export def F32_MANTISSA_BITS: u32 = 23u32;
 
-// The number of bits in the exponent of the binary representation of f32.
 // ref/hare/math/floats.ha:30
 export def F32_EXPONENT_BITS: u32 = 8u32;
 
@@ -97,15 +84,12 @@ export def F32_EXPONENT_BITS: u32 = 8u32;
 // ref/hare/math/floats.ha:33
 export def F32_EXPONENT_BIAS: u32 = 127u32;
 
-// Mask with each bit of an f32's mantissa set.
 // ref/hare/math/floats.ha:43
 export def F32_MANTISSA_MASK: u32 = (1u32 << F32_MANTISSA_BITS) - 1u32;
 
-// Mask with each bit of an f32's exponent set.
 // ref/hare/math/floats.ha:46
 export def F32_EXPONENT_MASK: u32 = (1u32 << F32_EXPONENT_BITS) - 1u32;
 
-// The mask that gets an f32's sign.
 // ref/hare/math/floats.ha:87
 def F32_SIGN_MASK: u32 = 1u32 << 31;
 
@@ -127,15 +111,10 @@ def F32_EXP_ZERO: u32 = (F32_EXPONENT_BIAS - 1u32) << F32_MANTISSA_BITS;
 // against ref/hare/strconv/stof.ha:248,288 (`let e: int = 0` arithmetic
 // against `f.expbias` of the same type, no cast at use site).
 export type floatinfo = struct {
-	// Bits in significand.
 	mantbits: u64,
-	// Bits in exponent.
 	expbits: u64,
-	// Bias of exponent.
 	expbias: int,
-	// Mask for mantissa.
 	mantmask: u64,
-	// Mask for exponent.
 	expmask: u64,
 };
 
@@ -177,14 +156,12 @@ export def f32info: floatinfo = floatinfo {
 export def NAN_BITS: u64 = 0x7FF8000000000000u64;
 export def INF_BITS: u64 = 0x7FF0000000000000u64;
 
-// Returns true if the given floating-point number is NaN.
 // ref/hare/math/floats.ha:144 (Hare's expression body inlined into a
 // block: ww has no expression-bodied fn form, only brace blocks).
 export fn isnan(n: f64) bool = {
 	return n != n;
 };
 
-// Returns true if the given floating-point number is infinite.
 // ref/hare/math/floats.ha:147
 export fn isinf(n: f64) bool = {
 	const bits = f64bits(n);
@@ -193,7 +170,6 @@ export fn isinf(n: f64) bool = {
 	return exp == F64_EXPONENT_MASK && mant == 0;
 };
 
-// Returns true if the given f64 is subnormal.
 // ref/hare/math/floats.ha:179
 export fn issubnormalf64(n: f64) bool = {
 	const bits = f64bits(n);
@@ -202,7 +178,6 @@ export fn issubnormalf64(n: f64) bool = {
 	return exp == 0 && mant != 0;
 };
 
-// Returns the absolute value of f64 n.
 // ref/hare/math/floats.ha:195
 export fn absf64(n: f64) f64 = {
 	if (isnan(n)) {
@@ -222,19 +197,16 @@ export fn signf64(x: f64) i64 = {
 	};
 };
 
-// Returns whether or not x is positive.
 // ref/hare/math/floats.ha:231
 export fn ispositivef64(x: f64) bool = {
 	return signf64(x) == 1i64;
 };
 
-// Returns whether or not x is negative.
 // ref/hare/math/floats.ha:237
 export fn isnegativef64(x: f64) bool = {
 	return signf64(x) == -1i64;
 };
 
-// Returns x, but with the sign of y.
 // ref/hare/math/floats.ha:243
 export fn copysignf64(x: f64, y: f64) f64 = {
 	return f64frombits((f64bits(x) & ~F64_SIGN_MASK) |