Bug: resolve_references does not resolve references held in list fields

从 rune/runtime/base_data_class.py 的 resolve_references 开始：递归步骤已经处理列表字段，而引用解析步骤仅对属性值本身检查 isinstance(obj, (UnresolvedReference, Reference))。先运行 issue 中自包含的复现测试以确认失败，然后扩展解析步骤以遍历列表元素并按索引写回结果，绕过 Pydantic 的不可变性，方式与 _bind_property_to 对标量引用的处理相同。完成的标准是复现中的两个断言都通过，并且现有测试套件仍然通过。

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.