[Gitflow] Merge master into develop

…o 0.36.1 (#12240)

We are safe to change this now.

This PR introduces `Sentry.reactErrorHandler`, which looks like so:

```js
import * as Sentry from '@sentry/react';
import { hydrateRoot } from "react-dom/client";

ReactDOM.hydrateRoot(
  document.getElementById("root"),
  <React.StrictMode>
    <App />
  </React.StrictMode>,
  {
    onUncaughtError: Sentry.reactErrorHandler(),
    onCaughtError: Sentry.reactErrorHandler((error, errorInfo) => {
      // optional callback if users want custom config.
    }),
  }
);
```

To validate this change, we add a react 19 e2e test.

To avoid too large payloads, we should only send up to 1000 spans.

We actually had two different problems here in browser and node:

1. In browser, we _did_ limit to 1000, but we did so in an unfortunate
way, which is to reset the set after 1000 spans. So if a span had 1010
children, only the last 10 would be send.
2. In node, we just sent all spans.

I rewrote this to now consistently send the first 1000 spans of a
transaction.

I decided to keep all spans (no matter the limit) on the internal
parent-child map. Due to this this may grow a lot, but we can avoid
inconsistent state (e.g. what happens if a span has a parent in the map,
but the parent does not have the span as children, ...)
All of these should be garbage collected together ideally, so this
should be fine hopefully.

This does two main things:

1. Updates node E2E tests to use `fetch` instead of axios
2. Update node E2E tests to avoid sending to Sentry.

Instead, we check everywhere via the proxy that the data sent is OK.


Part of #11910

Fixes #12217

Make sure `failure_issue_threshold` and `recovery_threshold` get passed
in correctly.

This PR adds request data to server-side Sentry events by extracting the
request object in our `sentryHandle` request handler. This is in line
with our other SDKs and was simply missing from the SvelteKit SDK so
far.

…24.1 (#12238)

This introduces a new method, `metrics.timing()`, which can be used in
two ways:

1. With a numeric value, to simplify creating a distribution metric.
This will default to `second` as unit:

```js
Sentry.metrics.timing('myMetric', 100);
```

2. With a callback, which will wrap the duration of the callback. This
can accept a sync or async callback. It will create an inactive span
around the callback and at the end emit a metric with the duration of
the span in seconds:

```js
const returnValue = Sentry.metrics.timing('myMetric', measureThisFunction);
```

Closes #12215

This PR implements a versioned Sentry carrier as described in #12188.
The idea is that SDKs can from now on access their global Sentry
instance and thereby no longer overwrite or interfere with potentially
other SDKs (e.g. 3rd party libraries, scripts, etc).

Internally, SDKs can access their carrier via the
`window.__SENTRY__[SDK_VERSION]`. Externally (spotlight, loader script)
via `window.__SENTRY__[window.__SENTRY__.version]`.

---------

Co-authored-by: Francesco Novy <francesco.novy@sentry.io>

Noticed this while looking into
#12244, console
should be instrumented just fine in the CDN bundle.

Update CHANGELOG.md

Co-authored-by: Francesco Novy <francesco.novy@sentry.io>