Introduce the `Datadog::Tracing::Transport::Native::TraceExporter`
class backed by libdatadog's `ddog_TraceExporter` FFI.

`TraceExporter._native_new(url, tracer_version, language, ...)` builds
a Rust `TraceExporter` through the config/build pattern:

- Validates argument types upfront (before allocating Rust resources)
- Creates a `ddog_TraceExporterConfig`, applies each setting via
  `SET_CONFIG` macro with cleanup-on-error
- Builds the exporter and wraps it in Ruby `TypedData`

The `TraceExporter` is freed via `ddog_trace_exporter_free` on GC.
`Response` and `_native_send_traces` will follow.

Introduce `Datadog::Tracing::Transport::Native::Response` with the
full set of predicate methods expected by the `Writer`:

- `ok?`, `internal_error?`, `server_error?`, `client_error?`,
  `not_found?`, `unsupported?`
- `trace_count` and `payload` (agent response body for sampling
  rate feedback)

Two C helpers build responses from the native side:

- `create_ok_response`: success with optional payload
- `create_error_response`: classifies `ddog_TraceExporterErrorCode`
  into client/server/internal error categories

These will be used by `_native_send_traces` in the next step.

Implement `TraceExporter#_native_send_traces(traces)` which takes an
`Array<Array<Span>>`, converts each span to Rust via the C FFI,
groups them into trace chunks, and sends them to the Datadog Agent.

Key safety patterns:

- `rb_ensure` guarantees Rust-allocated trace chunks are freed if a
  Ruby exception fires during span conversion
- `rb_thread_call_without_gvl2` releases the GVL during the blocking
  network send so other Ruby threads can run
- The "gvl2" variant is used (not plain `gvl`) to prevent automatic
  interrupt raising before Rust response/error objects are inspected
  and freed
- A retry loop handles the case where an interrupt causes `gvl2` to
  return before the send function actually runs

The agent's response body (containing `rate_by_service` for sampling
feedback) is extracted and surfaced via `Response#payload`.

This completes the C extension for the native trace transport.

Classes created with `rb_define_class_under` are attached to their
parent module's constant table, making them reachable by GC.
Marking them as GC roots with `rb_global_variable` is unnecessary.

Delegate to the existing helper instead of duplicating the
`RSTRING_PTR`/`RSTRING_LEN` construction and type check inline.

Use a typed function pointer and a `static inline` function instead of
a preprocessor macro. Same codegen, easier to debug and type-check.

Adopt the same pattern used by the profiling extension: a
`process_pending_interruptions` callback paired with a
`check_if_pending_exception` wrapper that returns the pending state
as an integer instead of requiring manual `rb_protect` at the call
site.

Replace the `ddog_TraceExporterResponse **response_out` double pointer
with a `ddog_TraceExporterResponse *response` field and pass its
address to the FFI call. This removes one level of indirection and
keeps all send-related state within the args struct.

Use a descriptive variable name for the cast data pointer.

Move error handling into `send_chunks_without_gvl`: extract the error
code enum and free the `ddog_TraceExporterError` before returning.
After reacquiring the GVL only the plain `error_code` and `failed`
flag remain, eliminating the need to free Rust-allocated error objects
on every code path.

Accept keyword arguments via `rb_scan_args(argc, argv, "0:", ...)`
instead of 9 positional VALUE parameters. This makes call sites
self-documenting and prevents silent argument ordering mistakes.

The Ruby call becomes:
  TraceExporter._native_new(url:, tracer_version:, language:, ...)

Define Response in Ruby with keyword-argument `initialize` and
`attr_reader` accessors. The C extension loads the class at init time
via `rb_require` and calls `Response.new(ok:, ...)` through
`rb_funcallv_kw` instead of manually setting instance variables.

This gives Ruby's JIT better visibility into the object shape and
reduces the amount of C code.

Count entries skipped due to unexpected types during hash iteration
and log a warning after the loop completes. Previously these entries
were silently dropped, making it difficult to diagnose missing tags.

Replace two `rb_funcall` calls (`to_i` + `nsec`) with a single
`rb_time_timespec` call that extracts the underlying `struct timespec`
directly from the Ruby Time object. Zero method dispatch overhead.

Replace two `rb_funcall` calls (`&` and `>>`) with direct extraction
via `rb_big_pack`, which copies the Bignum magnitude into a word
buffer without method dispatch or temporary object allocation.

A Fixnum fast path handles the common case of 64-bit trace IDs with
a simple `FIX2LONG` cast.

Construct a `ddog_TracerSpanFields` struct with designated initializers
and pass it by reference to `ddog_tracer_span_new`. This matches the
updated libdatadog FFI signature and is self-documenting at the call
site.

Hoist `span_count` before `ddog_tracer_trace_chunks_begin_chunk` and
pass it as the capacity argument to pre-allocate the inner span
vector.

The error path is unreachable in practice (the handle is always
valid), but the return value must still be freed to avoid leaking
the Rust-allocated error object.

The native trace exporter / transport specs need the libdatadog_api
extension, so they can't run in spec:main (no compile). Put them in a
dedicated NATIVE_TRANSPORT_SPECS group and a new spec:native_transport
task (enhance([:compile])): excluded from spec:main, listed in spec:all,
and added to the Matrixfile.

Keep them OUT of core_with_libdatadog_api: that pool also runs the
fork-heavy ProcessDiscovery specs, and a live native exporter
(SharedRuntime threads) present when ProcessDiscovery forks deadlocks the
child until fork safety lands (#5835). A separate task runs them in their
own process.