docs: add Resolution order section to RFC-017

Spell out the topological resolution rule for inputs in an article.
Covers why YAML order breaks on the alcoholwet/kieswet patterns, the
graph edges drawn from `source.parameters`, `source.select_on[*].value`,
and `temporal.reference`, and the cycle fallback behaviour.

Pairs with the engine change on feat/foreach-implementation that
implements the rule.

Author: anneschuth

docs/rfcs/rfc-017.md

@@ -173,6 +173,86 @@ When the input is named differently from the underlying column, `field` carries
         value: "0599"
 ```
 
+## Resolution order
+
+Inputs in an article can reference each other through `$name` inside
+`source.parameters`, `source.select_on[*].value`, and
+`temporal.reference`. The engine resolves inputs in a **topological
+order** driven by those references, not in YAML order.
+
+### Why topological, not YAML
+
+Take the Rotterdam alcohol-licence article from poc-machine-law:
+
+```yaml
+input:
+  - name: leeftijd_exploitant
+    source:
+      regulation: wet_brp
+      output: leeftijd
+      parameters: {bsn: $bsn}
+  - name: voldoet_aan_nationale_eisen
+    source:
+      regulation: alcoholwet/vergunning
+      parameters:
+        leeftijd_leidinggevende: $leeftijd_exploitant
+        vloeroppervlakte: $vloeroppervlakte_horecalokaliteit
+        type_bedrijf: $type_bedrijf
+  - name: bsn
+    source: {table: leidinggevenden, field: bsn, select_on: [{name: kvk_nummer, value: $kvk_nummer}]}
+  - name: vloeroppervlakte_horecalokaliteit
+    source: {table: inrichtingen, field: vloeroppervlakte_horecalokaliteit, select_on: [{name: kvk_nummer, value: $kvk_nummer}]}
+  - name: type_bedrijf
+    source: {table: inrichtingen, field: type_bedrijf, select_on: [{name: kvk_nummer, value: $kvk_nummer}]}
+```
+
+`leeftijd_exploitant` references `$bsn`, but `bsn` is declared later.
+A strict YAML-order walk resolves `leeftijd_exploitant` first, sees
+`$bsn` as Null (lenient resolution returns Null for unknown names),
+and feeds a null BSN into the cross-law call, which returns garbage.
+`voldoet_aan_nationale_eisen` has the same problem against three later
+inputs. `kieswet/KIESRAAD-2024-01-01.yaml` shows the same pattern with
+`$verkiezingsdatum` as the last input of the article.
+
+Law authors write inputs grouped by semantic cluster (all BRP inputs
+together, all licensing criteria together, all raw municipal table
+inputs at the bottom), not in dependency order. Forcing them to reorder
+by dependency makes the YAML less readable and ties the file to an
+implementation detail.
+
+### Rule
+
+Before resolving the inputs of an article, the engine computes a
+directed graph:
+
+* Node per declared input.
+* Edge from `I` to `J` when `I` carries a `$J` reference in
+  `source.parameters`, `source.select_on[*].value`, or
+  `temporal.reference`, and `J` is the name of another input in the
+  same article.
+* References to runtime parameters (names that match
+  `execution.parameters`, not `execution.input`) are **not** edges.
+* Dot notation `$obj.field` creates an edge on the base name `obj`.
+
+The engine resolves inputs in a topological order of this graph. When
+multiple orderings are legal, YAML order breaks ties so the trace
+output stays stable and predictable.
+
+### Cycles
+
+If the graph contains a cycle (input A references B references A, or
+an input references itself), the engine logs a warning via `tracing`
+and falls back to YAML order for the whole article. No panic, no
+hard error. This preserves the prior behaviour for malformed articles
+while making the failure visible.
+
+### Host implications
+
+Hosts that pre-resolve inputs before calling the engine (legacy path)
+must either resolve in the same topological order or let the engine do
+it. Hosts that register data sources and hand the parameters dict to
+`evaluate_law_output` get the correct behaviour automatically.
+
 ## Implementation notes
 
 * The engine's data source registry already supports key-based lookup (`DictDataSource`). A new `RecordSetDataSource` adds multi-criteria filtering, field aliases, and array projection.