chore(native): declare PyContextVar_* locally for limited-API builds

pyo3-ffi gates its entire `context` module behind `not(Py_LIMITED_API)`
(pyo3-ffi 0.28.3 `src/lib.rs` lines 436 and 503), so `ffi::PyContextVar_New`,
`ffi::PyContextVar_Get` and `ffi::PyContextVar_Set` disappear whenever the
extension is built against the stable ABI. On CPython 3.15 that happens via
`PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1`, since pyo3-build-config 0.28.3 caps
`ABI3_MAX_MINOR` at 14. The build then fails with three E0425 "cannot find
function ... in module `ffi`" errors on this file.

Declare the three stable C API entry points locally so the module compiles in
both configurations. Context variables date to Python 3.7, so the symbols are
present on every interpreter ddtrace supports; verified to compile clean on
3.9, 3.13 and 3.15 with and without the stable-ABI path.

Same class of fix as #18429, which closed the sibling `PyFrame_GetBack` gap for
the crashtracker.

Extracted from fc09033 on #19833, which
bundled it with three unrelated formatting fixes. The code is unchanged from
that commit; only the explanatory comment above the declarations was reworded.

Co-authored-by: Vlad Scherbich <vlad.scherbich@datadoghq.com>

Author: wconti27

src/native/contextvar.rs

@@ -2,6 +2,23 @@ use pyo3::ffi;
 use pyo3::prelude::*;
 use std::ffi::CString;
 
+// PyContextVar_New/_Get/_Set are absent from pyo3-ffi's stable/limited-API bindings
+// (Py_LIMITED_API), which is activated for Python 3.15+ via PYO3_USE_ABI3_FORWARD_COMPATIBILITY.
+// Declare the stable C API locally so this module builds either way. Context variables were
+// introduced in Python 3.7, so these symbols are available on every supported interpreter.
+unsafe extern "C" {
+    fn PyContextVar_New(
+        name: *const std::os::raw::c_char,
+        def: *mut ffi::PyObject,
+    ) -> *mut ffi::PyObject;
+    fn PyContextVar_Get(
+        var: *mut ffi::PyObject,
+        default_value: *mut ffi::PyObject,
+        value: *mut *mut ffi::PyObject,
+    ) -> std::os::raw::c_int;
+    fn PyContextVar_Set(var: *mut ffi::PyObject, value: *mut ffi::PyObject) -> *mut ffi::PyObject;
+}
+
 /// Create a new `contextvars.ContextVar` via the C API (`PyContextVar_New`)
 /// with `default` as its default value. Avoids importing the `contextvars`
 /// module from Rust.
@@ -13,9 +30,7 @@ pub fn contextvar_new<'py>(
     let c_name = CString::new(name).expect("contextvar name must not contain NUL bytes");
     // SAFETY: `c_name` is a valid NUL-terminated string for the duration of the call;
     // `default.as_ptr()` is a valid borrowed reference (PyContextVar_New takes its own ref).
-    unsafe {
-        Bound::from_owned_ptr_or_err(py, ffi::PyContextVar_New(c_name.as_ptr(), default.as_ptr()))
-    }
+    unsafe { Bound::from_owned_ptr_or_err(py, PyContextVar_New(c_name.as_ptr(), default.as_ptr())) }
 }
 
 /// Read the current value of `var` via `PyContextVar_Get`.
@@ -28,7 +43,7 @@ pub fn contextvar_get<'py>(
 ) -> PyResult<Bound<'py, PyAny>> {
     let mut value: *mut ffi::PyObject = std::ptr::null_mut();
     // SAFETY: `var` is a valid ContextVar object; `value` is a valid out-pointer.
-    let rc = unsafe { ffi::PyContextVar_Get(var.as_ptr(), std::ptr::null_mut(), &mut value) };
+    let rc = unsafe { PyContextVar_Get(var.as_ptr(), std::ptr::null_mut(), &mut value) };
     if rc < 0 {
         return Err(PyErr::take(py).unwrap_or_else(|| {
             pyo3::exceptions::PyRuntimeError::new_err("PyContextVar_Get failed")
@@ -80,7 +95,7 @@ pub fn safe_contextvar_set(
             }));
         }
 
-        let token = ffi::PyContextVar_Set(var.as_ptr(), value.as_ptr());
+        let token = PyContextVar_Set(var.as_ptr(), value.as_ptr());
 
         // Capture any error before the decrefs below can perturb interpreter state.
         let err = if token.is_null() {
@@ -113,7 +128,7 @@ pub fn safe_contextvar_set(
 ) -> PyResult<()> {
     // SAFETY: the GIL (`py`) is held for the duration of the call.
     unsafe {
-        let token = ffi::PyContextVar_Set(var.as_ptr(), value.as_ptr());
+        let token = PyContextVar_Set(var.as_ptr(), value.as_ptr());
         if token.is_null() {
             return Err(PyErr::take(py).unwrap_or_else(|| {
                 PyErr::new::<pyo3::exceptions::PyRuntimeError, _>("PyContextVar_Set failed")