Bug: resolve_references does not resolve references held in list fields

Comienza en rune/runtime/base_data_class.py, en resolve_references: el paso de recursión ya maneja los campos de lista, mientras que el paso de resolución de referencias solo comprueba isinstance(obj, (UnresolvedReference, Reference)) en el valor de la propiedad en sí. Ejecuta primero la prueba de reproducción autocontenida del issue para confirmar el fallo, y luego extiende el paso de resolución para iterar sobre los elementos de la lista y escribir los resultados por índice, eludiendo la inmutabilidad de Pydantic de la misma manera que _bind_property_to lo hace para las referencias escalares. Se da por terminado cuando ambas aserciones de la repro pasan y la suite de tests existente sigue pasando.

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.