test(sql-contract-psl): cover two distinct M:N relations between the same model pair

The relation-name disambiguation that resolves self-referential many-to-many
sides is general: it equally distinguishes two separate many-to-many relations
between the same pair of distinct models, each through its own junction. That
path was exercised only for the same-model (self-referential) permutation.

Add two interpreter cases for the distinct-models shape (User <-> Tag through
TagOwnership and TagWatch): one where both list fields and their junction
parent-side FKs carry matching @relation names, asserting both relations lower
to N:M with the correct through descriptors and the contract validates fully;
and one without relation names, asserting the PSL_AMBIGUOUS_BACKRELATION_LIST
diagnostic. No implementation change — the behaviour was already correct.

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

Author: tensordreams

packages/2-sql/2-authoring/contract-psl/test/interpreter.relations.many-to-many.test.ts

@@ -432,6 +432,144 @@ model Follow {
     );
   });
 
+  it('lowers two distinct named many-to-many relations between the same pair through separate junctions', () => {
+    const result = interpretSchema(`model User {
+  id Int @id
+  ownedTags Tag[] @relation("owned")
+  watchedTags Tag[] @relation("watched")
+}
+
+model Tag {
+  id Int @id
+  owners User[] @relation("owned")
+  watchers User[] @relation("watched")
+}
+
+model TagOwnership {
+  userId Int
+  tagId Int
+  user User @relation("owned", fields: [userId], references: [id])
+  tag Tag @relation("owned", fields: [tagId], references: [id])
+
+  @@id([userId, tagId])
+}
+
+model TagWatch {
+  userId Int
+  tagId Int
+  user User @relation("watched", fields: [userId], references: [id])
+  tag Tag @relation("watched", fields: [tagId], references: [id])
+
+  @@id([userId, tagId])
+}
+`);
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+
+    const models = relationsOf(result.value);
+    expect(models['User']?.relations).toEqual({
+      ownedTags: {
+        to: crossRef('Tag', 'public'),
+        cardinality: 'N:M',
+        on: { localFields: ['id'], targetFields: ['userId'] },
+        through: {
+          table: 'tagOwnership',
+          namespaceId: 'public',
+          parentColumns: ['userId'],
+          childColumns: ['tagId'],
+          targetColumns: ['id'],
+        },
+      },
+      watchedTags: {
+        to: crossRef('Tag', 'public'),
+        cardinality: 'N:M',
+        on: { localFields: ['id'], targetFields: ['userId'] },
+        through: {
+          table: 'tagWatch',
+          namespaceId: 'public',
+          parentColumns: ['userId'],
+          childColumns: ['tagId'],
+          targetColumns: ['id'],
+        },
+      },
+    });
+    expect(models['Tag']?.relations).toEqual({
+      owners: {
+        to: crossRef('User', 'public'),
+        cardinality: 'N:M',
+        on: { localFields: ['id'], targetFields: ['tagId'] },
+        through: {
+          table: 'tagOwnership',
+          namespaceId: 'public',
+          parentColumns: ['tagId'],
+          childColumns: ['userId'],
+          targetColumns: ['id'],
+        },
+      },
+      watchers: {
+        to: crossRef('User', 'public'),
+        cardinality: 'N:M',
+        on: { localFields: ['id'], targetFields: ['tagId'] },
+        through: {
+          table: 'tagWatch',
+          namespaceId: 'public',
+          parentColumns: ['tagId'],
+          childColumns: ['userId'],
+          targetColumns: ['id'],
+        },
+      },
+    });
+
+    const envelope = JSON.parse(JSON.stringify(result.value)) as unknown;
+    expect(() => validateSqlContractFully<Contract<SqlStorage>>(envelope)).not.toThrow();
+  });
+
+  it('returns diagnostics for two unnamed many-to-many relations between the same pair', () => {
+    const result = interpretSchema(`model User {
+  id Int @id
+  ownedTags Tag[]
+  watchedTags Tag[]
+}
+
+model Tag {
+  id Int @id
+  owners User[]
+  watchers User[]
+}
+
+model TagOwnership {
+  userId Int
+  tagId Int
+  user User @relation(fields: [userId], references: [id])
+  tag Tag @relation(fields: [tagId], references: [id])
+
+  @@id([userId, tagId])
+}
+
+model TagWatch {
+  userId Int
+  tagId Int
+  user User @relation(fields: [userId], references: [id])
+  tag Tag @relation(fields: [tagId], references: [id])
+
+  @@id([userId, tagId])
+}
+`);
+
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+
+    expect(result.failure.diagnostics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
+          message: expect.stringContaining('User.ownedTags'),
+        }),
+      ]),
+    );
+  });
+
   it('keeps the orphaned diagnostic for bare lists without any junction model', () => {
     const result = interpretSchema(`model Post {
   id Int @id