Add initial end-to-end CUDA FGMRES solver path

[LwhJesse]

Proposed Changes

This PR adds an end-to-end CUDA linear solve path: the Krylov solvers keep their host control flow, and CSysVector operations, the SpMV and the Jacobi preconditioner are dispatched to CUDA kernels when ENABLE_CUDA=YES.

Transfers are explicit and owned by the object responsible for the data, with no coherency or dirty-flag tracking in CSysVector / CSysMatrix:

• CSysMatrixVectorProduct uploads the matrix on construction
• the preconditioner uploads its data in Build()
• CSysSolve uploads b and x and downloads x in HandleTemporariesIn/Out, which is also where device evaluation is switched on and off
• preconditioners without a device implementation (ILU, LU-SGS, Linelet, PaStiX) download the input, apply on the host, and upload the result

A solve is therefore fully device resident for Identity and Jacobi preconditioners: 2 uploads and 1 download per linear system, independent of the Krylov subspace size.

Implementation notes:

• cuBLAS for dot / norm, custom kernels for the block-LDU SpMV, the Jacobi apply, and CSysVector expression assignment
• CSysVector operands are captured in expressions by value, so an arbitrary expression tree is trivially copyable into the assignment kernel; the required expression shapes are explicitly instantiated in CSysVectorGPU.cu, consistent with how CSysMatrix is instantiated
• device work is issued by a single thread with the OpenMP team synchronized around it, so the GPU path is usable from inside the existing parallel regions; this is internal to the linear algebra layer
• the CUDA translation units are only linked into the primal libraries, since they cannot be compiled with the CoDiPack defines; device dispatch is compiled out of the AD builds
• adds LINEAR_SOLVER_PREC= NONE (identity)

Related Work

Follows the review direction in #2822 (show a working end-to-end GPU linear solve before splitting out infrastructure) and the implementation preferences in #2816.

Validation

• CPU vs GPU on inviscid NACA0012, 25 iterations, RTX 4070 Ti SUPER (sm_89), for FGMRES + JACOBI, FGMRES + NONE, FGMRES + ILU (host preconditioner path) and BCGSTAB. Results agree to the printed precision in double, and to ~6 significant figures in mixed precision. BCGSTAB agrees exactly once the linear system is converged (LINEAR_SOLVER_ERROR=1e-10); at loose tolerances the two paths diverge through BCGSTAB's own sensitivity, not a difference in the algebra.
• Mixed, normal and single precision builds all compile and run; device dispatch confirmed live in each (kernel launch counts track the subspace size).
• OMP_NUM_THREADS=1 and 4 give bit-identical results on the GPU path.
• Builds verified: primal, primal + AD + directdiff, enable-cuda + with-omp, mixed / normal / single precision.
• Transfer counts measured per solve: 2 H2D + 1 D2H + 1 matrix upload for Jacobi and NONE, plus one download/upload pair per preconditioner application for ILU.

Earlier validation of the original design (6 representative cases, nsys / ncu profiling) predates the rework of the transfer and dispatch model and should be repeated.

PR Checklist

• I am submitting my contribution to the develop branch.
• My contribution generates no new compiler warnings (try with --warnlevel=3 when using meson).
• My contribution is commented and consistent with SU2 style (https://su2code.github.io/docs_v7/Style-Guide/).
• I used the pre-commit hook to prevent dirty commits and used pre-commit run --all to format old commits.
• I have added a test case that demonstrates my contribution, if necessary.
• I have updated appropriate documentation (Tutorials, Docs Page, config_template.cpp), if necessary.