feat(contract-psl): arrow-path through: column-based M:N recognition

Recognise the arrow-path many-to-many form
`through: "localKey -> Junction.nearCol -> Junction.farCol -> Target.targetKey"`
on terminal models over a junction that carries scalar columns + @@id but no
relation fields. The relation-field-based junction recognition cannot fire when
the junction declares no relation fields, so the resolver builds the `through`
descriptor straight from the path-named columns.

Value form: a quoted string (no grammar change). The parser already produces a
StringLiteralExpr; the resolver detects the `->` separator, strips quotes, and
splits the four segments. An unquoted arrow grammar would require a new
tokenizer token plus an expression node, AST class, union/cast extension,
printSyntax rendering, and formatter spacing rules — out of scope for this
escape-hatch slice.

Each end carries its own mirror-imaged path; both ends lower to N:M + through.
Diagnostics: malformed path (not four segments / bad arrows), a named column
absent on its model, the two junction columns on different models, and a
junction that is not a declared model.

Signed-off-by: Alexey Orlenko's AI Agent <robot@aqrln.net>

Author: tensordreams

packages/2-sql/2-authoring/contract-psl/src/interpreter.ts

@@ -94,6 +94,7 @@ import {
 } from './psl-field-resolution';
 import { resolveNamedTypeDeclarations } from './psl-named-type-resolution';
 import {
+  type ArrowPath,
   applyBackrelationCandidates,
   type FkRelationMetadata,
   indexFkRelations,
@@ -520,6 +521,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     });
     const relationAttribute = getAttribute(field.attributes, 'relation');
     let through: ParsedThrough | undefined;
+    let arrowPath: ArrowPath | undefined;
     let inverse: string | undefined;
     if (relationAttribute) {
       const parsedRelation = parseRelationAttribute({
@@ -551,6 +553,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
         continue;
       }
       through = parsedRelation.through;
+      arrowPath = parsedRelation.arrowPath;
       inverse = parsedRelation.inverse;
     }
     if (!attributesValid) {
@@ -563,6 +566,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       field,
       targetModelName: field.typeName,
       ...ifDefined('through', through),
+      ...ifDefined('arrowPath', arrowPath),
       ...ifDefined('inverse', inverse),
     });
   }
@@ -2056,19 +2060,27 @@ export function interpretPslDocumentToSqlContract(
   const modelIdColumns = new Map<string, readonly string[]>();
   const modelTableNames = new Map<string, string>();
   const declaredTableNames = new Set<string>();
+  // Field-name → storage-column maps per model, so an arrow-path `through:` can
+  // resolve its path-named columns straight from the declared models.
+  const modelFieldColumns = new Map<string, ReadonlyMap<string, string>>();
   for (const modelNode of modelNodes) {
     if (modelNode.id) {
       modelIdColumns.set(modelNode.modelName, modelNode.id.columns);
     }
     modelTableNames.set(modelNode.modelName, modelNode.tableName);
     declaredTableNames.add(modelNode.modelName);
     declaredTableNames.add(modelNode.tableName);
+    modelFieldColumns.set(
+      modelNode.modelName,
+      new Map(modelNode.fields.map((field) => [field.fieldName, field.columnName])),
+    );
   }
   const { synthesizedJunctions } = applyBackrelationCandidates({
     backrelationCandidates,
     fkRelationsByPair,
     fkRelationsByDeclaringModel,
     modelIdColumns,
+    modelFieldColumns,
     modelTableNames,
     modelNamespaceIds,
     declaredTableNames,