## Context
Common API queries load selected relations after fetching the root
records.
Relation loading is batched: one query pipeline loads a relation for all
parent records, so this is not an N+1 problem. However, every sibling
relation currently starts concurrently through `Promise.all`.
Nested relations repeat the same behavior recursively. A wide selection
can therefore submit many independent relation query pipelines at once.
Existing query complexity and record limits restrict what can be
requested, but they do not limit how much database work starts
concurrently.
## What this changes
This PR adds a request-local FIFO concurrency limiter for nested
relation loading.
- At most four `findRelations` pipelines execute concurrently.
- One limiter is created for the outer relation-loading call.
- The same limiter is shared by every recursive level.
- Queued work starts as permits become available.
- Permits are released in `finally`, including when a query fails.
Conceptually:
```text
Before:
all sibling relations -> database concurrently
nested siblings -> more database work concurrently
After:
all sibling relations -> FIFO queue -> at most 4 database pipelines
nested siblings -> same FIFO queue and same limit
```
Note: Also addressing
https://github.com/twentyhq/twenty/pull/23251#discussion_r3644510597
Weiko
abe4d7491c