Bug: resolve_references does not resolve references held in list fields

rune/runtime/base_data_class.py の resolve_references から着手する。再帰ステップはすでにリストフィールドを処理しているが、参照解決ステップはプロパティ値自体に対して isinstance(obj, (UnresolvedReference, Reference)) を確認するだけである。まず issue に添付された自己完結の再現テストを実行して失敗を確認し、その後、解決ステップを拡張してリスト要素を反復処理し、結果をインデックスで書き戻すようにする。スカラー参照に対して _bind_property_to が行うのと同様に Pydantic の不変性を回避すること。再現テストの両アサーションが通り、既存のテストスートも引き続き通ることで完了とする。

Bug Report

BaseDataClass.resolve_references only resolves references that are the direct value of a property. When a property holds a list, references within that list are silently skipped, leaving them as UnresolvedReference objects rather than the resolved instances.

Steps to Reproduce

1. Define a Rune model with a type that has a multi-cardinality reference field (i.e., a field typed as a list of another type, decorated with @ref metadata):

   type Party:
       [metadata key]
       name string (1..1)
   
   type Contract:
       parties Party (2..*)
           [metadata reference]
   

2. Generate Python from the model. The parties field will be typed as a list with a reference validator:

   parties: Annotated[
       list[Party | BaseReference | None],
       Party.serializer(),
       Party.validator(('@key', '@key:external', '@ref', '@ref:external'))
   ] = Field(..., min_length=2)
   

3. Deserialize a JSON document where the list field contains @ref entries:

   {
     "@type": "...",
     "party": [
       {"identifier": [{"id": {"@data": "p1"}}], "name": "Buyer"},
       {"identifier": [{"id": {"@data": "p2"}}], "name": "Seller"}
     ],
     "contract": {
       "@type": "...",
       "parties": [
         {"@ref": "p1"},
         {"@ref": "p2"}
       ]
     }
   }
   

4. Call BaseDataClass.rune_deserialize(json_str).

The following self-contained test reproduces the failure without a generator or CDM dependency:

from typing import Annotated, Optional
from pydantic import Field
from rune.runtime.base_data_class import BaseDataClass
from rune.runtime.metadata import BaseReference, UnresolvedReference

# --- minimal model ---

class Observation(BaseDataClass):
    value: str = Field(...)

class Reset(BaseDataClass):
    # single-cardinality reference — works correctly
    primaryObservation: Optional[Annotated[
        Observation,
        Observation.serializer(),
        Observation.validator(('@key', '@ref')),
    ]] = Field(None)

    # multi-cardinality reference — broken
    observations: Annotated[
        list[Observation | BaseReference | None],
        Observation.serializer(),
        Observation.validator(('@key', '@ref')),
    ] = Field(default_factory=list)

# --- JSON: one object defines @key, the other field references it via @ref ---

data = {
    'primaryObservation': {'@key': 'obs-1', 'value': '1.234'},
    'observations': [
        {'@ref': 'obs-1'},   # should resolve to the Observation above
    ],
}

model = Reset.rune_deserialize(data, validate_model=False)

# Scalar reference: resolved correctly
assert isinstance(model.primaryObservation, Observation), \
    f'Expected Observation, got {type(model.primaryObservation)}'

# List reference: NOT resolved — this assertion FAILS
assert isinstance(model.observations[0], Observation), \
    f'Expected Observation, got {type(model.observations[0])}'
# -> AssertionError: Expected Observation, got <class 'rune.runtime.metadata.UnresolvedReference'>

Expected Result

Reference resolution completes successfully. Each element of contract.parties is resolved to its corresponding Party instance — the same outcome as for a singular reference field.

Actual Result

The references in contract.parties are silently left as UnresolvedReference objects. No exception is raised during deserialization, but any attempt to use the field values fails at runtime because the elements are UnresolvedReference instances rather than Party instances.

Root cause: BaseDataClass.resolve_references (in base_data_class.py) iterates self.__dict__ and resolves properties whose value is directly an UnresolvedReference:

for prop_nm, obj in self.__dict__.items():
    if isinstance(obj, (UnresolvedReference, Reference)):   # <-- checks the property value
        refs.append((prop_nm, obj.get_reference(self)))

For a list field, obj is the list itself — not an UnresolvedReference — so the condition is False and none of the references inside the list are ever resolved.

The earlier loop in the same method already handles lists correctly for the recursion step (finding BaseDataClass children to recurse into), but the reference-resolution step does not apply the same pattern.

Environment

• rune-python-runtime current main
• Observed during ingestion of CDM production samples

Additional Context

The fix requires iterating list elements in the resolution step, analogous to the existing recursion step:

for prop_nm, obj in self.__dict__.items():
    if isinstance(obj, (UnresolvedReference, Reference)):
        refs.append((prop_nm, obj.get_reference(self)))
    elif isinstance(obj, (MutableSequence, tuple)):
        for i, item in enumerate(obj):
            if isinstance(item, (UnresolvedReference, Reference)):
                list_refs.append((prop_nm, i, item.get_reference(self)))

Resolved items must then be written back into the list by index, and the binding must bypass Pydantic's immutability the same way the scalar case does via _bind_property_to.