Add CUDA NEP backend and GPU neighbor lists

[19hello]

Summary

This PR adds a CUDA NEP backend and GPU neighbor-list implementation for molecular dynamics.

Main changes:

• Add the optional CUDA NEP backend under source/source_esolver/nep_gpu.
• Add GPU neighbor-list construction under source/source_cell/module_neighlist/gpu_neighlist.
• Split the existing CPU neighbor-list implementation into cpu_neighlist.
• Move domain_decomposition directly under source/source_cell.
• Add the ENABLE_NEP_GPU CMake option.
• Add a silicon NEP GPU validation case.

Implementation

The GPU NEP backend provides two main interfaces:

• initialize()

  • Selects the CUDA device.
  • Creates the GPU-side NEP model.
  • Uploads NEP parameters to the GPU.

• compute()

  • Prepares coordinates and atom types.
  • Builds or reuses the GPU neighbor list.
  • Evaluates NEP descriptors on the GPU.
  • Computes radial forces, angular forces, energy, and virial.
  • Copies the results back to the MD layer.

The GPU neighbor-list implementation uses spatial binning and CUDA kernels for:

• Bin construction.
• Candidate-neighbor search.
• Neighbor-count reduction.
• Neighbor-index filling.
• Candidate-list filtering.

Build

CUDA NEP can be enabled with:

cmake -S . -B build_nep_gpu \
  -DUSE_CUDA=ON \
  -DENABLE_NEP_GPU=ON \
  -DENABLE_LCAO=OFF \
  -DENABLE_LIBRI=OFF \
  -DNEP_DIR=<NEP installation path> \
  -DCMAKE_CUDA_COMPILER=/usr/local/cuda-12.0/bin/nvcc \
  -DCMAKE_CUDA_ARCHITECTURES=75

## Verification

Environment:

- GPU: NVIDIA GeForce RTX 2080 Ti
- CUDA Toolkit: 12.0.76
- CUDA architecture: 75
- MPI processes: 1
- OMP_NUM_THREADS=1

Completed tests:

- GPU NEP initialization and MD execution.
- GPU neighbor-list path with 100,000 atoms.
- CPU neighbor-list plus GPU NEP with 100,000 atoms.
- CPU neighbor-list plus GPU NEP with 500,000 atoms.
- CPU neighbor-list plus GPU NEP with 1,000,000 atoms.
- CPU and GPU NEP energy results matched for the validation case.
- git diff --check passed.
- ABACUS governance check passed with header-dependency warnings only.

The large-scale MD tests used:

md_nstep          5
md_neighbor_skin  0
device            gpu
esolver_type      nep
OMP_NUM_THREADS   1
MPI processes      1

## Performance observation

For the CPU-neighbor-list plus GPU-NEP path:

500,000 atoms:
    Total time:              89.49 s
    CPU neighbor preparation: 86.42 s
    GPU NEP compute:           1.65 s

1,000,000 atoms:
    Total time:              176.50 s
    CPU neighbor preparation: 170.80 s
    GPU NEP compute:           2.95 s

With md_neighbor_skin=0, the neighbor list is rebuilt at every MD step.

## Known limitations

- The GPU neighbor-list implementation still performs some bin-offset preparation on the host.
- The GPU backend currently supports potential-only, non-ZBL NEP models.
- CPU and GPU neighbor lists are separate implementations. The GPU NEP path uses its own device-resident neighbor list.
- GPU-specific unit tests and broader numerical regression tests should be expanded in follow-up work.

## Build note

The previously configured ENABLE_LCAO=OFF incremental build reached the link stage but failed because existing module_current/td_current_io*.cpp
objects require LCAO-only symbols. This is unrelated to the GPU NEP changes. The GPU executable was built successfully in the earlier GPU validation
build and was used for the runtime tests described above.