fix(codegen): stabilize Used By sort order

After resolving type name collisions across themes (101596f),
two referrers from different modules can share a display name.
The sort key (kind, name) produced ties, and Python's sorted()
preserved set iteration order for tied elements -- which depends
on id()-based hashing and varies across process invocations.

Add the source module as a tiebreaker: (kind, name, module).
Expose TypeIdentity.module property to encapsulate the
getattr(obj, "__module__") access pattern.

Author: mojodna

packages/overture-schema-codegen/src/overture/schema/codegen/reverse_references.py

@@ -159,10 +159,15 @@ def collect_from_newtype_spec(spec: NewTypeSpec, referrer: TypeIdentity) -> None
         elif isinstance(supp_spec, ModelSpec):
             collect_from_model_spec(supp_spec, tid)
 
-    # Sort sets into lists
+    # Sort into deterministic lists. (kind, name) handles the common case;
+    # module breaks ties when two referrers share the same display name
+    # (e.g. identically-named types from different themes/modules).
     result: dict[TypeIdentity, list[UsedByEntry]] = {}
     for target, ref_set in references.items():
-        entries = sorted(ref_set, key=lambda e: (e.kind.value, e.identity.name))
+        entries = sorted(
+            ref_set,
+            key=lambda e: (e.kind.value, e.identity.name, e.identity.module),
+        )
         result[target] = entries
 
     return result

packages/overture-schema-codegen/src/overture/schema/codegen/specs.py

@@ -58,6 +58,11 @@ def __eq__(self, other: object) -> bool:
     def __hash__(self) -> int:
         return id(self.obj)
 
+    @property
+    def module(self) -> str:
+        """Source module of the underlying object, or empty string."""
+        return getattr(self.obj, "__module__", "")
+
 
 class _SourceTypeIdentityMixin:
     """Mixin providing ``identity`` from ``source_type`` and ``name``.

packages/overture-schema-codegen/tests/test_reverse_references.py

@@ -1,5 +1,6 @@
 """Tests for reverse reference computation."""
 
+from enum import Enum as PyEnum
 from typing import NewType
 
 import pytest
@@ -14,6 +15,7 @@
     lookup_by_name,
     make_union_spec,
 )
+from overture.schema.codegen.enum_extraction import extract_enum
 from overture.schema.codegen.model_extraction import expand_model_tree, extract_model
 from overture.schema.codegen.newtype_extraction import extract_newtype
 from overture.schema.codegen.reverse_references import (
@@ -24,6 +26,7 @@
 from overture.schema.codegen.type_collection import collect_all_supplementary_types
 from overture.schema.system.ref import Id
 from overture.schema.system.string import NoWhitespaceString
+from pydantic import BaseModel
 
 
 @pytest.mark.parametrize(
@@ -150,6 +153,41 @@ def test_pydantic_type_has_used_by_from_feature() -> None:
     assert any(e.identity.name == "FeatureWithUrl" for e in entries)
 
 
+def test_sort_tiebreaker_uses_module_for_same_name_referrers() -> None:
+    """Referrers with the same name sort deterministically by module."""
+
+    # Two model classes named "Feature" from different modules.
+    class SharedEnum(PyEnum):
+        A = "a"
+
+    class FeatureAlpha(BaseModel):
+        value: SharedEnum
+
+    class FeatureBeta(BaseModel):
+        value: SharedEnum
+
+    FeatureAlpha.__name__ = "Feature"
+    FeatureAlpha.__module__ = "alpha.models"
+    FeatureBeta.__name__ = "Feature"
+    FeatureBeta.__module__ = "beta.models"
+
+    spec_a = extract_model(FeatureAlpha, entry_point="Feature")
+    spec_b = extract_model(FeatureBeta, entry_point="Feature")
+    expand_model_tree(spec_a)
+    expand_model_tree(spec_b)
+
+    enum_id = TypeIdentity(SharedEnum, "SharedEnum")
+    all_specs = {enum_id: extract_enum(SharedEnum)}
+
+    result = compute_reverse_references([spec_a, spec_b], all_specs)
+
+    entries = lookup_by_name(result, "SharedEnum")
+    assert len(entries) == 2
+    # Both named "Feature" — module provides the tiebreaker
+    modules = [e.identity.module for e in entries]
+    assert modules == ["alpha.models", "beta.models"]
+
+
 def test_sorting_models_before_newtypes() -> None:
     """Sorting produces models before NewTypes, alphabetical within groups."""
     # Create a test where the same type (Id) is referenced by: