feat(search)!: implement inline references and class-less reference types

[ddeboer]

Implements #608.

Realises the inline reference strategy that ADR 8 forward-declared and
ADR 11 decided:
reach a qualified or deep RDF value by inlining a reference and deriving from it,
never by growing the path grammar. Builds on #607 (the path/derive split and
internal fields).

What changed

• Reference types – SearchType is now RootType | ReferenceType, told
  apart by one absence: a Root Type declares a class (indexed, keys the
  schema, earns a collection); a Reference Type declares none and is reached
  only through an inline reference. searchSchema partitions its arguments –
  root types key the class map, reference types go into a name index an inline
  ref.typeName resolves against. Because schema.values() yields only root
  types, no writer ever opens a run/collection for a reference type, and an
  indexed reference type fails to compile (the engine port and Typesense
  adapter are constrained to root types).

• strategy: 'inline' – projection now carries a referent’s own projected
  fields. A referent is projected through its reference type as a nested
  SearchDocument (an array for an array reference), recursing to the depth
  the schema declares. Roles decide whether the nesting surfaces: a role-less
  inline reference is a reading device (internal, projected so a derive can
  flatten a value a path cannot address, then pruned before the writer); an
  output one is an API device that surfaces the nested type. So RDF depth
  and API shape stay independent.

• Framing depth – frameSubjects gains a depth parameter and follows the
  reference graph breadth-first (visiting each subject once, so a data cycle
  terminates). projectRoots derives the depth from the schema
  (inlineFramingDepth), floored at one hop, so the existing single-hop embed
  is preserved. Depth is a bounded property of the declaration, not a knob.

• Validation – searchSchema now checks that every inline ref.typeName
  resolves to a declared reference type and rejects inline cycles (the only way
  framing depth could be unbounded), at construction rather than index time.

Scope

idOnly stays a forward declaration; only inline is implemented here. The
Dataset Register migration (a separate repo, gated on #548) is out of scope –
this PR builds the LDE mechanism only.

Breaking

class is now optional on SearchType, and inline ref resolution is enforced
at searchSchema construction – a breaking @lde/search API change (feat!).