The DI preload path (datadog/di/preload -> base) activates code tracking
before Datadog::Core is loaded, so the catch-all rescue handlers on that
path cannot reference Core. Define FATAL_EXCEPTION_CLASSES and
reraise_if_fatal under Datadog::DI instead, in a small dependency-free
file, and drop them from Core.

Convert every catch-all rescue (rescue => e / bare rescue) in the DI
subtree to rescue Exception and re-raise process-fatal exceptions
(SystemExit, SignalException, NoMemoryError) via DI.reraise_if_fatal,
catching everything else. Previously these handlers caught only
StandardError, so a non-StandardError such as NotImplementedError would
escape and could kill a background thread.

Typed rescues are left narrow. The serializer keeps its own
SERIALIZER_FATAL_EXCEPTION_CLASSES (without NoMemoryError) because it must
return a safe stub rather than tear the process down when serializing a
large or deeply recursive object.

Convert every catch-all rescue in the symbol database subtree to
rescue Exception and re-raise process-fatal exceptions via
DI.reraise_if_fatal, catching everything else. This stops a
non-StandardError (e.g. NotImplementedError from a customer-overridden
.name) from aborting the whole extraction pass and silently killing the
scheduler thread; such a class is now logged and skipped.

Each affected file requires datadog/di/fatal_exceptions directly.

Adds the missing signature file for lib/datadog/di/fatal_exceptions.rb,
which was failing `rake rbs:missing` (and therefore steep/typecheck and
all-jobs-are-green): every new file under lib/ needs a matching sig/ file.

Also renames the serializer constant in its RBS to match the source: the
code renamed FATAL_EXCEPTION_CLASSES to SERIALIZER_FATAL_EXCEPTION_CLASSES,
but the signature still declared the old name, which would have failed
`steep check` once rbs:missing passed.

Covers the behavior change that had no tests:

- Datadog::DI.reraise_if_fatal: re-raises each fatal class (SystemExit,
  SignalException, Interrupt, NoMemoryError) and returns for non-fatal
  ones (StandardError, NotImplementedError, LoadError, SystemStackError);
  also pins FATAL_EXCEPTION_CLASSES contents and frozen-ness.

- Extractor#extract_all: continues (returns [], logs) when introspection
  raises a non-StandardError such as NotImplementedError -- the scenario
  that previously killed the scheduler thread -- and still propagates a
  fatal exception.

- Serializer custom-serializer condition path: skips the serializer when
  the condition raises a non-StandardError, and propagates a fatal one.

- Serializer main path: propagates a fatal exception instead of returning
  a safe stub (complements the existing NoMemoryError-is-caught test).

steep/typecheck failed:
  lib/datadog/di/transport/input.rb:116:116: [error]
  Type `(::Array[::String] | nil)` does not have method `first`
  (Ruby::NoMethod)

Root cause: this PR broadened the catch-all rescues from `rescue => exc`
(implicit StandardError) to `rescue Exception => exc`. With the implicit
form Steep types `exc` as untyped and does not check the receiver of
`exc.backtrace.first`; with the explicit class Steep types `exc` as
`Exception`, whose `#backtrace` is `Array[String]?` in the stdlib RBS, so
`.first` on a possibly-nil array is flagged. The backtrace-logging line
itself is unchanged — the stricter rescue type is what surfaced the latent
nil dereference.

`Exception#backtrace` genuinely can be nil (no backtrace before raise,
set_backtrace with strings, or an overridden #backtrace — see
probe_notification_builder.rb), and `rescue Exception` now catches the
broader set of exception classes where that is more likely. So this is a
real nil-safety fix, not a Steep workaround: guard with `&.first`. When
backtrace is present the behavior is identical; when nil the debug log
interpolates an empty string instead of raising NoMethodError.

The same `exc.backtrace.first` pattern appears in two more sites that this
PR converted to `rescue Exception` — probe_notifier_worker.rb:99 and :325.
Steep did not flag them only because probe_notifier_worker.rb is in the
Steepfile ignore list, but the latent nil dereference is identical. Fixed
all three for consistency.

Verified: ruby -c clean on both files. `&.first` on `Array[String]?` is the
standard Steep-accepted nil-safe idiom and resolves the Ruby::NoMethod
diagnostic. Steep was not run locally -- bundle install fails here with
Bundler::PermissionError (gem dir not writable); the steep/typecheck CI job
validates.

Remove the FATAL_EXCEPTION_CLASSES contents assertion (it mirrors the constant
and breaks on any edit) and the is-frozen test; the fatal/non-fatal behavior is
already exercised by the .reraise_if_fatal cases. Add a test asserting
reraise_if_fatal preserves the original backtrace when re-raising.

Addresses review comments on fatal_exceptions_spec.rb.

Rename SERIALIZER_FATAL_EXCEPTION_CLASSES across the definition, the three
serializer rescue sites, and the RBS signature. No behavior change.

Addresses review comment on serializer.rb.

Add @param/@return YARD tags to Datadog::DI.reraise_if_fatal so the
public helper's contract is explicit (type of exc, nil-on-non-fatal
return).