Resolve v0.1.0 open questions and fix production-readiness issues

POC: /workspace/alktype-builder-poc/ (18/18 tests pass, findings in
docs/research/alktype-builder-poc/findings.md). Round 2 adds the SFTP
Packet validate_bytes tests (7 new: valid Init/Read/Write/Status,
short buffer, unknown discriminator, over-maxLength Bytes).

Open questions resolved (OQ-004 through OQ-008):
- OQ-004: Discriminator::Field name is String (already implemented;
  docs updated to mark resolved)
- OQ-005: Both union discriminator kinds return the same shape:
  {__discriminator, ...variant-fields}. Field-name path also had a
  real offset bug (returned start, not end) - fixed.
- OQ-006: builder.md Example 3 now wraps the Union in a
  Schema::struct_().field("payload", ...) and merges $defs via
  Definitions::merge_into (matches the engine's AlkType:Struct-at-root
  constraint and the SFTP wire shape)
- OQ-007: Bytes materialization is array-of-u8 (Value::Array of
  Value::Number, one entry per byte 0..=255). BytesValidator accepts
  both Value::String (validate_json) and Value::Array (validate_bytes).
  maxLength = max byte count. Replaces the lossy from_utf8_lossy path
  that corrupted non-UTF-8 bytes and broke maxLength semantics.
- OQ-008 (new): UnionValidator now dispatches to variant schemas via
  sub-validators built at factory time. AlkTypeEngine::compile calls
  schema::inline_union_variant_refs before build_validator to inline
  $refs in union mapping entries (necessary because union_factory
  receives the union node, but $defs live at the schema root).

Production-readiness fixes in src/ (no stubs/hedges in a published crate):
- materialize.rs: Record stub -> full count-prefixed key/value pair
  implementation per schema-layer.md TRecord
- materialize.rs: root_of() was broken (returned the current node, not
  the schema root) -> root schema threaded through every recursive call
  so resolve_ref_or_inline can resolve $refs for nested composites
- builder.rs: LengthPrefixed encoding setter was a no-op when the
  keyword was already in object form -> complete the branch (updates
  the encoding entry in place for both LengthPrefixed and OffsetIndirect)
- builder.rs, engine.rs: POC-referencing comments cleaned up; the
  round-trip test's or_else fallback (papering over write_field being
  aligned-only) replaced with direct byte writes

Documentation:
- builder.md: Example 3 updated; Discriminator::Field spec shows String;
  Open Questions section updated (OQ-004 resolved)
- validation.md: AlkType:Bytes and AlkType:Union validator descriptions
  updated for array-of-u8 form and variant dispatch
- open-questions.md: OQ-004/005/006/007/008 marked resolved; new
  Validation theme entries
- questions/004-008: individual OQ files updated with resolutions
- findings.md: round 2 results documented

Verification:
- cargo test: 369 -> 391 tests pass (22 new: 14 materialize, 5
  inline_union_variant_refs, 3 validation/builder)
- cargo clippy --all-targets: clean
- POC: 11 -> 18 tests (7 new SFTP Packet tests); all pass

docs/architecture/builder.md

@@ -359,7 +359,7 @@ pub enum Discriminator {
     /// Field-name discriminator (ADR-003 §4 Kind B).
     /// `name` is the field holding the discriminator value.
     Field {
-        name: &str,  // or String — see "Open question" below
+        name: String,
     },
 }
 ```
@@ -536,8 +536,15 @@ let read_file_input = Schema::object()
 
 ### Example 3: SFTP `Packet` union (binary layout, byte discriminator)
 
+The SFTP wire shape is `[type:u8][payload-struct]` — a struct with a
+union payload field. The engine requires `AlkType:Struct` at the top
+level (`OffsetMap::compute` / `SequentialReader::new` both enforce
+this; a `Union` is a field type within a struct, not a top-level
+schema). The builder constructs the union wrapped in a struct, and
+`$defs` are merged into the top-level schema so `$ref`s resolve:
+
 ```rust
-use alktype::{Schema, Discriminator, AlkTypeKind};
+use alktype::{Definitions, Discriminator, AlkTypeKind, Schema};
 
 let mut defs = Definitions::new();
 defs.define("Init",  Schema::struct_().field("version", Schema::uint32()));
@@ -546,16 +553,26 @@ defs.define("Read",  Schema::struct_().field("handle", Schema::bytes()).field("o
 defs.define("Write", Schema::struct_().field("handle", Schema::bytes()).field("offset", Schema::uint64()).field("data", Schema::bytes()));
 defs.define("Status", Schema::struct_().field("code", Schema::uint32()).field("message", Schema::string()));
 
-let packet = Schema::union_(Discriminator::Byte {
-        offset: 0,
-        disc_type: AlkTypeKind::Uint8,
-    })
-    .mapping("1",   Schema::ref_def("Init"))
-    .mapping("3",   Schema::ref_def("Open"))
-    .mapping("5",   Schema::ref_def("Read"))
-    .mapping("6",   Schema::ref_def("Write"))
-    .mapping("101", Schema::ref_def("Status"))
+// A "Packet" is a struct with one field — the union. This mirrors
+// SFTP's wire shape: [type:u8][payload-struct].
+let mut packet = Schema::struct_()
+    .field(
+        "payload",
+        Schema::union_(Discriminator::Byte {
+            offset: 0,
+            disc_type: AlkTypeKind::Uint8,
+        })
+        .mapping("1",   Schema::ref_def("Init"))
+        .mapping("3",   Schema::ref_def("Open"))
+        .mapping("5",   Schema::ref_def("Read"))
+        .mapping("6",   Schema::ref_def("Write"))
+        .mapping("101", Schema::ref_def("Status")),
+    )
     .build();
+// Merge $defs into the top-level schema so $refs resolve at compile time.
+defs.merge_into(&mut packet);
+// Feed to AlkTypeEngine::compile(&mut packet, LayoutMode::Packed)
+// then validate incoming frames via engine.validate_bytes(&frame).
 ```
 
 ### Example 4: OperationSpec error schemas (named `$defs`)
@@ -606,12 +623,13 @@ let op_errors = vec![
 
 ## Open Questions
 
-- **OQ-004** (open): `Discriminator::Field` name type — `&str` or
-  `String`? The builder consumes `Self` on each setter, so the
-  discriminator's `name` needs to outlive the `Schema` it's embedded
-  in. `&str` borrows; `String` owns. Tracked in
-  [open-questions.md](open-questions.md); full file:
-  [OQ-004](questions/004-discriminator-field-name-type.md).
+None specific to the builder. OQ-003 (the original "should we build a
+builder API") is resolved by this spec / ADR-009. OQ-004
+(`Discriminator::Field` name type — `&str` or `String`) is resolved:
+`String`, for ownership simplicity (the builder consumes `Self` on
+setters; `&str` would require a lifetime parameter on `Discriminator`
+and transitively on `Schema::union_`). See
+[open-questions.md](open-questions.md).
 
 ## References