Resolve review #003 nits N1, N3, N4

- N1: number_from_f64 now returns AlkTypeError::Access for non-finite
  floats instead of silently materializing Value::Null. A NaN/Inf in the
  buffer surfaces as a clear access error rather than a misleading
  'expected a number' validation error.
- N3: drop the dead Value::String arm from check_bytes; the materializer
  only ever emits bytes as an array of u8. Update the validation-model
  docs to match.
- N4: fix stale ADR references in doc comments (ADR-096 -> ADR-002,
  ADR-097 -> ADR-003, ADR-098 -> ADR-004, ADR-101 -> ADR-007).

N2 (BastType::alk_kind returning Struct for ) left as documented;
every current caller resolves the ref first, so forcing Option through
the call sites is churn without benefit.

Verification: cargo test --release (411 pass), cargo clippy --all-targets
-- -D warnings (clean), cargo doc --no-deps (clean).

src/bast_validation.rs

@@ -211,48 +211,32 @@ fn check_string(value: &Value, path: &str, max_length: Option<usize>) -> Result<
 }
 
 fn check_bytes(value: &Value, path: &str, max_length: Option<usize>) -> Result<(), AlkTypeError> {
-    match value {
-        Value::String(s) => {
-            if let Some(max) = max_length {
-                if s.len() > max {
-                    return Err(validation_err(
-                        path,
-                        format!("bytes length {} exceeds maxLength {max}", s.len()),
-                    ));
-                }
-            }
-            Ok(())
+    let arr = value
+        .as_array()
+        .ok_or_else(|| validation_err(path, "expected an array of u8 for bytes"))?;
+    if let Some(max) = max_length {
+        if arr.len() > max {
+            return Err(validation_err(
+                path,
+                format!("bytes array length {} exceeds maxLength {max}", arr.len()),
+            ));
         }
-        Value::Array(arr) => {
-            if let Some(max) = max_length {
-                if arr.len() > max {
-                    return Err(validation_err(
-                        path,
-                        format!("bytes array length {} exceeds maxLength {max}", arr.len()),
-                    ));
-                }
-            }
-            for (i, entry) in arr.iter().enumerate() {
-                let n = entry.as_u64().ok_or_else(|| {
-                    validation_err(
-                        path,
-                        format!("bytes array entry {i} is not a non-negative integer"),
-                    )
-                })?;
-                if n > 255 {
-                    return Err(validation_err(
-                        path,
-                        format!("bytes array entry {i} = {n} is not a u8 (0..=255)"),
-                    ));
-                }
-            }
-            Ok(())
-        }
-        _ => Err(validation_err(
-            path,
-            "expected a string or array of u8 for bytes",
-        )),
     }
+    for (i, entry) in arr.iter().enumerate() {
+        let n = entry.as_u64().ok_or_else(|| {
+            validation_err(
+                path,
+                format!("bytes array entry {i} is not a non-negative integer"),
+            )
+        })?;
+        if n > 255 {
+            return Err(validation_err(
+                path,
+                format!("bytes array entry {i} = {n} is not a u8 (0..=255)"),
+            ));
+        }
+    }
+    Ok(())
 }
 
 fn validate_timestamp(value: &Value, path: &str) -> Result<(), AlkTypeError> {