cuda: bf16 cuBLAS GemmEx (16BF in/out, fp32 accum) + cast kernels

Add the bf16 compute primitives for T12 mixed precision:
- DType::BF16 (half::bf16 as TensorDType), 2 bytes.
- cublasGemmEx / cublasGemmStridedBatchedEx FFI + CUDA_R_16BF /
  CUBLAS_COMPUTE_32F constants (values per xserv gemm.rs).
- cublas::gemm_ex / gemm_ex_strided_batched: same row-major⟺col-major
  transpose algebra as sgemm, bf16 in/out, fp32 accumulation.
- csrc/ops/cast.cu: f32<->bf16 cast + bf16 elementwise (add/mul/scale/
  silu(+dx)/add_bias/sum_rows), each load->fp32->compute->store bf16.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

crates/xtrain-cuda/src/ffi.rs

@@ -324,3 +324,126 @@ unsafe extern "C" {
 pub const CUBLAS_OP_N: i32 = 0;
 #[cfg(not(no_cuda))]
 pub const CUBLAS_OP_T: i32 = 1;
+
+// --- bf16 mixed precision (Phase T12) ---
+//
+// cudaDataType / cublasComputeType enum values (same as xserv's gemm.rs). The
+// bf16 GEMM uses bf16 in/out with fp32 accumulation (CUBLAS_COMPUTE_32F).
+#[cfg(not(no_cuda))]
+pub const CUDA_R_32F: i32 = 0;
+#[cfg(not(no_cuda))]
+pub const CUDA_R_16BF: i32 = 14;
+#[cfg(not(no_cuda))]
+pub const CUBLAS_COMPUTE_32F: i32 = 68;
+/// CUBLAS_GEMM_DEFAULT — let cuBLAS pick the algorithm.
+#[cfg(not(no_cuda))]
+pub const CUBLAS_GEMM_DEFAULT: i32 = -1;
+
+#[cfg(not(no_cuda))]
+unsafe extern "C" {
+    // General GEMM with explicit in/out + compute types (bf16 path). `alpha`/
+    // `beta` are fp32 host scalars (compute type is fp32). Pointers are void* so
+    // the same FFI serves bf16 / fp32.
+    #[allow(clippy::too_many_arguments)]
+    pub fn cublasGemmEx(
+        handle: CublasHandle,
+        transa: i32,
+        transb: i32,
+        m: i32,
+        n: i32,
+        k: i32,
+        alpha: *const std::ffi::c_void,
+        a: *const std::ffi::c_void,
+        a_type: i32,
+        lda: i32,
+        b: *const std::ffi::c_void,
+        b_type: i32,
+        ldb: i32,
+        beta: *const std::ffi::c_void,
+        c: *mut std::ffi::c_void,
+        c_type: i32,
+        ldc: i32,
+        compute_type: i32,
+        algo: i32,
+    ) -> i32;
+    #[allow(clippy::too_many_arguments)]
+    pub fn cublasGemmStridedBatchedEx(
+        handle: CublasHandle,
+        transa: i32,
+        transb: i32,
+        m: i32,
+        n: i32,
+        k: i32,
+        alpha: *const std::ffi::c_void,
+        a: *const std::ffi::c_void,
+        a_type: i32,
+        lda: i32,
+        stride_a: i64,
+        b: *const std::ffi::c_void,
+        b_type: i32,
+        ldb: i32,
+        stride_b: i64,
+        beta: *const std::ffi::c_void,
+        c: *mut std::ffi::c_void,
+        c_type: i32,
+        ldc: i32,
+        stride_c: i64,
+        batch_count: i32,
+        compute_type: i32,
+        algo: i32,
+    ) -> i32;
+}
+
+// bf16 cast + elementwise kernels (csrc/ops/cast.cu). Pointers are void* (bf16
+// buffers); f32 sides are typed. The activation stream flows bf16; the math
+// accumulates in fp32 inside each kernel.
+#[cfg(not(no_cuda))]
+unsafe extern "C" {
+    pub fn launch_cast_f32_to_bf16(input: *const f32, out: *mut c_void, n: i32, s: CudaStream);
+    pub fn launch_cast_bf16_to_f32(input: *const c_void, out: *mut f32, n: i32, s: CudaStream);
+
+    pub fn launch_add_bf16(
+        a: *const c_void,
+        b: *const c_void,
+        out: *mut c_void,
+        n: i32,
+        s: CudaStream,
+    );
+    pub fn launch_mul_bf16(
+        a: *const c_void,
+        b: *const c_void,
+        out: *mut c_void,
+        n: i32,
+        s: CudaStream,
+    );
+    pub fn launch_scale_bf16(
+        input: *const c_void,
+        out: *mut c_void,
+        alpha: f32,
+        n: i32,
+        s: CudaStream,
+    );
+    pub fn launch_silu_bf16(x: *const c_void, y: *mut c_void, n: i32, s: CudaStream);
+    pub fn launch_silu_dx_bf16(
+        x: *const c_void,
+        dy: *const c_void,
+        dx: *mut c_void,
+        n: i32,
+        s: CudaStream,
+    );
+    pub fn launch_add_bias_bf16(
+        x: *const c_void,
+        bias: *const c_void,
+        out: *mut c_void,
+        rows: i32,
+        cols: i32,
+        s: CudaStream,
+    );
+    pub fn launch_sum_rows_bf16(
+        dout: *const c_void,
+        dbias: *mut c_void,
+        rows: i32,
+        cols: i32,
+        s: CudaStream,
+    );
+}