chore(sdk): deprecate queues.overrideConcurrencyLimit and resetConcurrencyLimit

## Summary

Marks `queues.overrideConcurrencyLimit` and
`queues.resetConcurrencyLimit` as deprecated in the SDK. These functions
belong to the legacy model where a queue carried its own concurrency
limit. On the current model a queue is only the ordered line runs wait
in, concurrency is declared on the task with the `concurrency` option,
and limits are managed through `concurrencyLimits.override` and
`concurrencyLimits.reset`. The server already rejects these calls for
queues on the current model.

The `@deprecated` JSDoc includes a migration example:

```ts
export const myTask = task({
  id: "my-task",
  concurrency: { total: 5 },
  run: async (payload) => {
    // ...
  },
});

await concurrencyLimits.override("task/my-task", { total: 10 });
```

Also adds a deprecation callout to the queues docs pointing at the
concurrency docs, plus a changeset.

`queues.pause` and `queues.resume` are intentionally not deprecated:
pausing a queue remains valid flow control on the current model.

Mono-RevId: e75902f159eda3487596ba4d038ed5eedc45bee8

Author: matt-aitken

.changeset/deprecate-queue-concurrency-mutations.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/sdk": patch
+---
+
+Deprecate `queues.overrideConcurrencyLimit` and `queues.resetConcurrencyLimit`. These operate on the legacy model where a queue carried its own concurrency limit; declare concurrency with the task `concurrency` option and manage it with `concurrencyLimits.override` and `concurrencyLimits.reset` instead.

docs/queues.mdx

@@ -210,6 +210,17 @@ await queues.resume({ type: "custom", name: "my-custom-queue" });
 
 ### Overriding concurrency limits
 
+<Warning>
+  `queues.overrideConcurrencyLimit` and `queues.resetConcurrencyLimit` are deprecated and only work
+  for queues on the legacy model, where the queue carried its own concurrency limit. On the current
+  model, declare concurrency with the task `concurrency` option and manage it through
+  [`concurrencyLimits`](/concurrency), e.g. `concurrencyLimits.override("task/my-task", { total: 10 })`
+  and `concurrencyLimits.reset("task/my-task")`. A legacy limit on a queue used with
+  `concurrencyKey` maps to `perKey` rather than `total`, and a limit on a custom queue shared by
+  several tasks maps to a named limit declared with `concurrencyLimit()`, again using `perKey`
+  when the queue receives keyed runs.
+</Warning>
+
 You can temporarily override a queue's concurrency limit. This is useful for scaling up or down based on demand:
 
 ```ts

packages/trigger-sdk/src/v3/queues.ts

@@ -137,6 +137,28 @@ export function pause(
 /**
  * Overrides the concurrency limit of a queue.
  *
+ * @deprecated Queue-level concurrency is the legacy model: a modern queue is only the
+ * ordered line runs wait in, and concurrency is declared on the task and managed
+ * through `concurrencyLimits`. The server rejects this call for queues on the new
+ * model. Migrate by declaring the limit and overriding it by name:
+ *
+ * ```ts
+ * export const myTask = task({
+ *   id: "my-task",
+ *   concurrency: { total: 5 },
+ *   run: async (payload) => {
+ *     // ...
+ *   },
+ * });
+ *
+ * await concurrencyLimits.override("task/my-task", { total: 10 });
+ * ```
+ *
+ * For workloads that pass a `concurrencyKey` at trigger time, declare `concurrency: { perKey: n }`
+ * instead (`total` caps all keys together). For a limit shared by several tasks, declare a named
+ * limit with `concurrencyLimit({ name, ... })`, making the same choice between `total` and
+ * `perKey`, pass it to each task's `concurrency` option, and override it by that name.
+ *
  * @param queue - The ID of the queue to override the concurrency limit, or the type and name
  * @param concurrencyLimit - The concurrency limit to override
  * @returns The updated queue state
@@ -175,6 +197,15 @@ export function overrideConcurrencyLimit(
 /**
  * Resets the concurrency limit of a queue to the base value.
  *
+ * @deprecated Queue-level concurrency is the legacy model: a modern queue is only the
+ * ordered line runs wait in, and concurrency is declared on the task and managed
+ * through `concurrencyLimits`. The server rejects this call for queues on the new
+ * model. Migrate by resetting the limit by name:
+ *
+ * ```ts
+ * await concurrencyLimits.reset("task/my-task");
+ * ```
+ *
  * @param queue - The ID of the queue to reset the concurrency limit, or the type and name
  * @returns The updated queue state
  */