fix(db-mongodb): remove duplicate IDs in nested relationship queries (#16354)

### What?

When querying through a nested relationship (e.g. `where: {
'movie.name': { equals: '...' } }`), the `$in` array used to filter
parent collection documents was populated with duplicate entries — each
document ID was pushed twice: once as a string and once as a
`Types.ObjectId`.

### Why?

In `buildSearchParams.ts`, the `else` branch (for non-`join` fields) was
doing:

**Before:**
  ```ts
  const stringID = doc._id.toString()
  $in.push(stringID)
  
  if (Types.ObjectId.isValid(stringID)) {
    $in.push(doc._id)
  }
```

Mongoose auto-casts 24-hex strings to ObjectId before sending queries to MongoDB, so both entries resolve to the same ObjectId. This caused every ID to appear twice in the $in array (e.g. 100 IDs → 200 entries), resulting in significantly larger queries, slower plaremnning times, and in extreme cases client disconnects due to timeouts.

How?

After:
```ts
$in.push(doc._id)
```

The _id returned by Mongoose's .lean() is already the correct BSON type — ObjectId for standard collections, string/number for custom ID collections — so no extra casting is needed.

A regression test was added to test/relationships/int.spec.ts that queries directors through a nested movie relationship using or conditions and asserts no duplicate documents are returned.

---------

Co-authored-by: Sasha Rakhmatulin <sasha@ritsuko.dev>

Author: ed-cscosta

packages/db-mongodb/src/queries/buildSearchParams.ts

@@ -217,10 +217,10 @@ export async function buildSearchParam({
               }
             } else {
               const stringID = doc._id.toString()
-              $in.push(stringID)
-
               if (Types.ObjectId.isValid(stringID)) {
                 $in.push(doc._id)
+              } else {
+                $in.push(stringID)
               }
             }
           })

test/relationships/int.spec.ts

@@ -473,6 +473,37 @@ describe('Relationships', () => {
         expect(res.docs[0].id).toBe(director_2.id)
       })
 
+      // MongoDB dedupes $in at execution, so the bug is only visible in the
+      // filter Payload hands to Mongoose — not in the returned docs.
+      mongoIt('should not duplicate IDs in $in when querying through a relationship', async () => {
+        const movie = await payload.create({
+          collection: 'movies',
+          data: { name: 'dup_test_movie' },
+        })
+
+        const Model = (payload.db as any).collections.directors
+        const originalPaginate = Model.paginate.bind(Model)
+        let capturedQuery: any
+        Model.paginate = (query: any, ...rest: any[]) => {
+          capturedQuery = query
+          return originalPaginate(query, ...rest)
+        }
+
+        try {
+          await payload.find({
+            collection: 'directors',
+            where: { 'movie.name': { equals: 'dup_test_movie' } },
+          })
+        } finally {
+          Model.paginate = originalPaginate
+        }
+
+        // eslint-disable-next-line vitest/no-standalone-expect
+        expect(capturedQuery.$and[0].movie.$in).toHaveLength(1)
+
+        await payload.delete({ collection: 'movies', id: movie.id })
+      })
+
       describe('hasMany relationships', () => {
         it('should retrieve totalDocs correctly with hasMany,', async () => {
           const movie1 = await payload.create({