fix(profiles,materialize,structure,consume): a block sources sequence is decoded, not skipped

One grammar, four call sites. `read_block_mappings` moves out of
`consume.read_sources` -- where it was written and measured -- into
`profiles`, the module both the flat readers and `consume` already import,
and the three copies of the line-oriented frontmatter grammar now decode a
block sequence for the keys `STRUCTURED_BLOCK_KEYS` names. Two copies of a
block grammar would be two answers to one question.

The value TYPE was the real choice and it was measured, not argued.
`parse_frontmatter` is public API (`okf.parse_frontmatter`) returning
`dict[str, str]`, and a list of mappings is not a `str`. Widening the return
type to `str | list[dict[str, str]]` costs 15 `mypy --strict` errors across
four of the five modules that touch the reader, plus a signature every
caller outside this repository would have to follow. Rendering the entries
back into the flow form those same readers already round-trip costs 0. The
rendering is a READING projection and says so: it is not a claim that the
value is writable -- `yaml_flow_plain` still refuses a `?` and the guard
still refuses a quote inside a flow mapping, which is why the producer
writes block in the first place.

`STRUCTURED_BLOCK_KEYS` is one key wide. `sources` is the key `read_sources`
already knows how to read; a fixture in this tree carries a block
`verified:` that still reads as an empty value, and a test pins that state
so the next widening is a decision rather than a side effect.

Nothing nested reaches the document's namespace: the entries land inside
their own value, and the K3-20 substitution guarantee is asserted per reader
copy.

Three tests that pinned the old behaviour are rewritten to what is now true,
none weakened on its other half: the block round trip in
`test_multi_source_provenance` (the evidence behind `_render_sources`'
reason 1), the v0.2 characterization (whose key-space assertion is the half
that must never weaken), and K3-22's shipped-file known-positive, where the
one difference is counted and pinned at 1.

Suite 1807 passed / 1 skipped, rc 0, 94 s -- 1782/1 before plus 25 new.
ruff clean, `mypy --strict` clean over 21 files, `uv.lock` untouched.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/llm_ingestion_okf/structure.py

@@ -35,7 +35,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 
 from .extract import strip_converter_attribute
-from .profiles import unquote_scalar
+from .profiles import STRUCTURED_BLOCK_KEYS, block_mapping_value, unquote_scalar
 
 # A document number is either an alpha-prefixed identifier (`N500`, `V720`,
 # `R610.4`) or a dotted numeric section (`4.2.1`). A BARE integer is
@@ -141,7 +141,7 @@ def _split_frontmatter(text: str) -> tuple[dict[str, str], int]:
         return {}, 0
     declared: dict[str, str] = {}
     offset = len(lines[0])
-    for line in lines[1:]:
+    for position, line in enumerate(lines[1:], start=1):
         offset += len(line)
         if line.strip() == "---":
             return declared, offset
@@ -150,13 +150,24 @@ def _split_frontmatter(text: str) -> tuple[dict[str, str], int]:
         # as the top-level keys and, arriving later, SUBSTITUTE for one of them
         # -- a `sources:` entry's own `title:` silently becoming the document's,
         # carrying `number` and `parent` with it. Skipping is deliberately not
-        # parsing: the nested value is not read, only refused. The structured
-        # reader is D1b.
+        # parsing: the nested value is not read, only refused. That refusal is
+        # unchanged by `STRUCTURED_BLOCK_KEYS`: a decoded block lands INSIDE
+        # its own value. The structured reader is still D1b.
         if line[:1] in (" ", "\t"):
             continue
         key, sep, value = line.partition(":")
         if sep:
-            declared[key.strip()] = _unquote(value.strip())
+            name, raw = key.strip(), value.strip()
+            # A block `sources:` is decoded rather than left empty (K3-24).
+            # The entries keep `unquote_scalar`'s rule, which is the rule the
+            # entries were written and read under, rather than this module's
+            # older `'`-stripping one -- one grammar for the block form.
+            rendered = (
+                block_mapping_value(lines, position)
+                if not raw and name in STRUCTURED_BLOCK_KEYS
+                else None
+            )
+            declared[name] = _unquote(raw) if rendered is None else rendered
     # An unterminated block is not frontmatter; the whole text is body.
     return {}, 0