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/validation.md

@@ -130,13 +130,18 @@ type constraints; `jsonschema` handles all structural validation.
   must not exceed it.
 
 **`AlkType:Bytes`:**
-- Value must be a string (JSON represents binary data as a string — JSON
-  has no native byte type).
-- If `maxLength` is specified, the byte length must not exceed it.
+- Value must be a string (the JSON form for `validate_json` consumers)
+  or an array of integers 0..=255 (the materialized form for
+  `validate_bytes`). JSON has no native byte type; the string form is
+  the JSON convention, the array form is the round-trippable form for
+  non-UTF-8 bytes (see [OQ-007](questions/007-bytes-materialization-lossy-utf8.md)).
+- If `maxLength` is specified, the byte length must not exceed it. For
+  the string form, this is the string's byte length; for the array
+  form, this is the array length (one entry per byte).
 - **Binary representation:** In the binary layout, `TBytes` is raw bytes
   with no encoding (not base64, not hex). The JSON representation (for
-  validation) uses a string; the binary representation (for data access)
-  uses `&[u8]` directly.
+  validation) uses a string or array; the binary representation (for
+  data access) uses `&[u8]` directly.
 
 **`AlkType:Enum`:**
 - The `AlkType:Enum` custom keyword signals that the type is an enum for
@@ -161,9 +166,23 @@ type constraints; `jsonschema` handles all structural validation.
   validate that each field's value matches its `AlkType:*` kind.
 
 **`AlkType:Union`:**
-- The discriminator value must be one of the mapping keys.
-- The variant struct must match the declared schema for that discriminator
-  value.
+- The instance must be an object with a `__discriminator` field
+  carrying the mapping key (stringified discriminator value for
+  byte-offset discriminators, string value for field-name
+  discriminators). This is the shape the materializer produces for
+  `validate_bytes`; `validate_json` consumers produce the same shape
+  when validating a union instance.
+- The `UnionValidator` builds a sub-validator for each variant at
+  factory time (when the parent validator tree is constructed) and
+  dispatches on `__discriminator` at validation time, validating the
+  full instance (including the variant fields) against the selected
+  variant's schema. This closes the OQ-008 gap: variant field
+  constraints (e.g. `maxLength` on a `Bytes` field inside a variant)
+  are checked.
+- `$ref`s in the union's `mapping` are inlined by
+  `schema::inline_union_variant_refs` during `AlkTypeEngine::compile`
+  (before `build_validator`), so the `union_factory` sees full inline
+  variant schemas. See [OQ-008](questions/008-unionvalidator-variant-dispatch.md).
 
 **`AlkType:Array`:**
 - Value must be an array.