Support timeouts in handlers

[timostamm]

This PR adds support for timeouts on the server side for all three protocols. This feature from gRPC is also known as deadlines, and it can be used to limit the time a server may take to process a response.

For example, when a client provides the timeoutMs call option, a header Connect-Timeout-Ms is added to the request. The server parses this timeout, and if it takes longer than the given timeout to process the request, it should give up, and respond with the error code deadline_exceeded.

On a connect-es server, the parsed timeout is available as an AbortSignal on the context:

import type { HandlerContext } from "@bufbuild/connect";

const say = async (req: SayRequest, ctx: HandlerContext) => {

  ctx.signal.aborted; // true if timed out
  ctx.signal.reason; // an error with code deadline_exceed if timed out

  // raises an error with code deadline_exceed if timed out
  ctx.signal.throwIfAborted();

  // the AbortSignal can be passed to other functions
  await longRunning(ctx.signal);

  return new SayResponse({sentence: `You said: ${req.sentence}`});
};

It is up to the implementation to honor the AbortSignal.

This also adds two related options to ConnectRouter:

  /**
   * The maximum value for timeouts that clients may specify.
   * If a clients requests a timeout that is greater than maxTimeoutMs,
   * the server responds with the error code InvalidArgument.
   */
  maxTimeoutMs: number;

  /**
   * To shut down servers gracefully, this option takes an AbortSignal.
   * If this signal is aborted, all `deadline` AbortSignals in handler contexts
   * will be aborted as well. This gives implementations a chance to wrap up
   * work before the server process is killed.
   */
  shutdownSignal?: AbortSignal;

Edit: The HandlerContext property was originally added as deadline?: AbortSignal in this PR, but #531 updated it to be signal: AbortSignal. The example above was updated.

Edit: #632 added a timeoutMs(): number | undefined method to the HandlerContext. It can be used to propagate the timeout to upstream RPCs.