## Overview

This PR implements support for SQL commenter plugins to Prisma Client, as described in the [RFC](https://www.notion.so/prismaio/SQL-Query-Comments-2b99e8aecef78057bbafd3f4fde73430). The feature will allow users to add metadata to SQL queries as comments following the [sqlcommenter format](https://google.github.io/sqlcommenter/).

## Goals

1. Create a new `@prisma/sqlcommenter` package with public-facing types
2. Implement the `SqlCommenterPlugin` interface and `SqlCommenterContext` type
3. Add a `comments` option to `PrismaClient` constructor
4. Implement the sqlcommenter algorithm for formatting comments
5. Integrate comment injection into the query execution pipeline (both LocalExecutor and RemoteExecutor/Accelerate)
6. Add unit tests

## Out of Scope

- Implementing actual plugins (e.g., `traceContext`, `queryInsights`)
- Deciding where the first-party plugins should be exported from (e.g., `@prisma/client/sqlcommenter`)


## Component Overview

We try to execute the comment plugins as close to the query execution time as possible, to have the most accurate context available.
However, for RemoteExecutor (Accelerate), we need to pre-compute the comments before sending the request to the query plan executor server because we can't serialize the plugins themselves.
This means that the future `traceContext` plugin will point at the query span as its traceparent when using LocalExecutor, but when using RemoteExecutor, the traceparent will be the `prisma:client:operation` span.

```
┌─────────────────────────────────────────────────────────────────┐
│                     PrismaClient Constructor                    │
│                                                                 │
│  new PrismaClient({                                             │
│    adapter: ...,                                                │
│    comments: [plugin1, plugin2, ...]  ← NEW OPTION              │
│  })                                                             │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                      EngineConfig                               │
│                                                                 │
│  - Stores the comments plugins array                            │
│  - Passes to LocalExecutor or RemoteExecutor                    │
└─────────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┴───────────────┐
              ▼                               ▼
┌──────────────────────────┐    ┌──────────────────────────┐
│     LocalExecutor        │    │     RemoteExecutor       │
│                          │    │     (Accelerate)         │
│  Passes plugins to       │    │                          │
│  QueryInterpreter        │    │  Pre-computes comments   │
│                          │    │  and sends in request    │
└──────────────────────────┘    └──────────────────────────┘
              │                               │
              ▼                               ▼
┌──────────────────────────┐    ┌──────────────────────────┐
│    QueryInterpreter      │    │   Query Plan Executor    │
│                          │    │                          │
│  For each SQL query:     │    │  Receives pre-computed   │
│  1. Call plugins         │    │  comments in request,    │
│  2. Merge results        │    │  uses constant plugin    │
│  3. Format & append      │    │  in QueryInterpreter     │
└──────────────────────────┘    └──────────────────────────┘
```

### Type Definitions

The typeswill live in a new `@prisma/sqlcommenter` package to keep plugin dependencies minimal:

```typescript
// packages/sqlcommenter/src/index.ts

/**
 * Information about a single Prisma query.
 */
export interface SqlCommenterSingleQueryInfo {
  /**
   * The model name (e.g., "User", "Post"). Undefined for raw queries.
   */
  modelName?: string

  /**
   * The Prisma operation (e.g., "findMany", "createOne", "queryRaw").
   */
  action: string

  /**
   * The full query object (selection, arguments, etc.).
   */
  query: unknown
}

/**
 * Information about the query or queries being executed.
 * 
 * - `single`: A single query is being executed
 * - `compacted`: Multiple queries have been compacted into a single SQL statement
 *   (e.g., automatic batching of findUnique queries, or explicit $transaction batches)
 */
export type SqlCommenterQueryInfo =
  | ({ type: 'single' } & SqlCommenterSingleQueryInfo)
  | { type: 'compacted'; queries: SqlCommenterSingleQueryInfo[] }

/**
 * Context provided to SQL commenter plugins.
 */
export interface SqlCommenterContext {
  /**
   * Information about the Prisma query being executed.
   */
  query: SqlCommenterQueryInfo
}

/**
 * A SQL commenter plugin that returns key-value pairs to be added as comments.
 * Return an empty object to add no comments.
 */
export interface SqlCommenterPlugin {
  (context: SqlCommenterContext): Record<string, string>
}
```

---

Ref: https://linear.app/prisma-company/issue/TML-1542/query-insights-statement-annotation
Closes: #13360
Closes: #8508
Closes: #10746