feat(model): resolve nested containers with parent pointers and inherited context

- Rebuild container tree setting `parent` on children and inheriting `context`
- Populate lookups using `containers_flat` to include nested containers

Author: akhundMurad

pacta/model/resolver.py

@@ -1,6 +1,7 @@
+from collections.abc import Mapping
 from dataclasses import dataclass, replace
 
-from pacta.model.types import ArchitectureModel
+from pacta.model.types import ArchitectureModel, Container
 
 
 @dataclass(frozen=True, slots=True)
@@ -12,20 +13,29 @@ class DefaultModelResolver:
       - container_to_context
       - path_roots
       - layer_patterns
+
+    For v2 models with nested containers:
+      - Rebuilds the container tree with ``parent`` set on children
+      - Children inherit parent ``context`` unless they define their own
+      - Populates lookups for all containers (including nested, via containers_flat)
     """
 
     def resolve(self, model: ArchitectureModel) -> ArchitectureModel:
+        # Rebuild container tree with parent pointers and context inheritance
+        resolved_containers = _resolve_children(model.containers, parent_qualified_id=None, parent_context=None)
+
+        model = replace(model, containers=resolved_containers)
+
         container_to_context: dict[str, str] = {}
         path_roots: dict[str, tuple[str, ...]] = {}
         layer_patterns: dict[str, dict[str, tuple[str, ...]]] = {}
 
-        for cid, c in model.containers.items():
+        for cid, c in model.containers_flat.items():
             if c.context:
                 container_to_context[cid] = c.context
 
             if c.code is not None:
                 roots = tuple(_norm_path(p) for p in c.code.roots if isinstance(p, str) and p.strip())
-                # deterministic
                 path_roots[cid] = tuple(sorted(set(roots)))
 
                 layer_map: dict[str, tuple[str, ...]] = {}
@@ -47,6 +57,25 @@ def resolve(self, model: ArchitectureModel) -> ArchitectureModel:
         )
 
 
+def _resolve_children(
+    containers: Mapping[str, Container],
+    parent_qualified_id: str | None,
+    parent_context: str | None,
+) -> dict[str, Container]:
+    """Recursively rebuild containers with ``parent`` and inherited ``context``."""
+    out: dict[str, Container] = {}
+    for cid, c in containers.items():
+        qualified = f"{parent_qualified_id}.{cid}" if parent_qualified_id else cid
+        context = c.context if c.context is not None else parent_context
+
+        resolved_children: dict[str, Container] = {}
+        if c.children:
+            resolved_children = _resolve_children(c.children, parent_qualified_id=qualified, parent_context=context)
+
+        out[cid] = replace(c, parent=parent_qualified_id, context=context, children=resolved_children)
+    return out
+
+
 def _norm_path(p: str) -> str:
     # Keep it simple and stable across OS:
     # - use forward slashes