Add Finder.findInParents to search ancestor chain for definitions

New companion object method searches the contents of each parent
in a hierarchy chain for definitions matching a type parameter.
Returns matches paired with their parent chain for PathIdentifier
construction. Useful for finding definitions in scope at a given
point in the AST hierarchy.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: reid-spencer

language/shared/src/main/scala/com/ossuminc/riddl/language/Finder.scala

@@ -207,4 +207,32 @@ object Finder:
     val container = SimpleContainer[CV](contents)
     Finder[CV](container)
   end apply
+
+  /** Search the contents of each parent in a hierarchy chain
+    * for definitions of type `T`. Walks from nearest parent
+    * to furthest (e.g., Entity → Context → Domain).
+    *
+    * @tparam T
+    *   The type of definition to find
+    * @param parents
+    *   The parent chain to search, ordered nearest to furthest
+    * @return
+    *   Each matching definition paired with the parents of the
+    *   container it was found in, suitable for constructing a
+    *   [[AST.PathIdentifier]]
+    */
+  def findInParents[T <: RiddlValue: ClassTag](
+    parents: Parents
+  ): Seq[(T, Parents)] =
+    val lookingFor = classTag[T].runtimeClass
+    val buffer = mutable.ArrayBuffer.empty[(T, Parents)]
+    parents.zipWithIndex.foreach { case (parent, idx) =>
+      val parentsOfParent = parents.drop(idx + 1)
+      parent.contents.toSeq.foreach { child =>
+        if lookingFor.isAssignableFrom(child.getClass) then
+          buffer += (child.asInstanceOf[T] -> parentsOfParent)
+      }
+    }
+    buffer.toSeq
+  end findInParents
 end Finder

language/shared/src/test/scala/com/ossuminc/riddl/language/SharedFinderTest.scala

@@ -8,7 +8,7 @@ package com.ossuminc.riddl.language
 
 import com.ossuminc.riddl.language.{Contents, *}
 import com.ossuminc.riddl.utils.pc
-import com.ossuminc.riddl.language.AST.{Root, Parents, RootContents}
+import com.ossuminc.riddl.language.AST.{Root, Parents, RootContents, Type, Handler, Entity, Context}
 import com.ossuminc.riddl.language.parsing.{
   AbstractParsingTest,
   RiddlParserInput,
@@ -58,6 +58,44 @@ class SharedFinderTest extends AbstractTestingBasis {
           s must be(Parents(c, b, a, root))
       }
     }
+    "findInParents finds definitions in ancestor chain" in {
+      val content2 =
+        """domain D {
+          |  type DomainCmd is command { ??? }
+          |  context C {
+          |    type CtxCmd is command { ??? }
+          |    entity E {
+          |      type EntCmd is command { ??? }
+          |      handler H { ??? }
+          |    }
+          |  }
+          |}
+          |""".stripMargin
+      val input2 = RiddlParserInput(content2, "findInParentsTest")
+      val root2 = TopLevelParser.parseInput(input2, true) match
+        case Left(messages) => fail(messages.justErrors.format)
+        case Right(r: Root) => r
+      val dom = root2.domains.head
+      val ctx = dom.contexts.head
+      val ent = ctx.entities.head
+      val handler = ent.handlers.head
+      // Parents of handler: Entity, Context, Domain, Root
+      val handlerParents = Parents(ent, ctx, dom, root2)
+      val found = Finder.findInParents[Type](handlerParents)
+      // Should find EntCmd in Entity, CtxCmd in Context,
+      // DomainCmd in Domain — 3 total
+      found.size must be(3)
+      val names = found.map(_._1.id.value)
+      names must contain("EntCmd")
+      names must contain("CtxCmd")
+      names must contain("DomainCmd")
+      // Verify parents: EntCmd's parents should be
+      // [Context, Domain, Root] (Entity's parents)
+      val entCmdParents = found.find(
+        _._1.id.value == "EntCmd"
+      ).get._2
+      entCmdParents must be(Parents(ctx, dom, root2))
+    }
     "build path map correctly" in {
       val a = root.modules.head
       val b = a.domains.head