Add CUDA graph capture/replay support with a graph-safe paged-attention decode path

[astorise]

Title: Add CUDA graph capture/replay support with a graph-safe paged-attention decode path

Summary

This PR adds three additive building blocks that together let a decode step
be captured once with a CUDA graph and replayed on every subsequent step,
composed with a vLLM-style paged KV cache:

1. candle_core::CudaGraph (candle-core/src/cuda_backend/graph.rs): a
   thin capture/replay wrapper around the CUDA stream-capture API, plus an
   htod-upload cache (CudaDevice::enable_cuda_graph_htod_cache) so that
   repeated host-constant uploads inside a captured closure reuse a cached
   allocation instead of failing capture.
2. PagedKvCache (candle-transformers/src/models/llama.rs):
   caller-owned, block-paged KV storage (vLLM-style) attached per
   transformer layer via Cache::set_paged_kv. When attached, that layer's
   attention routes through a paged/varlen flash-attention kernel against
   caller-managed key_cache/value_cache/block_table instead of the
   contiguous concat-and-narrow cache. Fully additive: layers default to the
   existing contiguous path.
3. Cache::set_decode_position: a caller-owned, persistent device
   tensor that a layer's rotary-embedding lookup reads via
   Tensor::index_select instead of narrow(0, index_pos, seq_len), so the
   RoPE lookup's device pointer doesn't get baked into a graph capture at a
   position that goes stale on replay.

The bug this PR also fixes (#3732)

With the above three in place, driving the paged decode path through an
actual CudaGraph::capture surfaces a fourth gap: PagedKvCache's
scatter-index computation for writing new K/V is not graph-capturable.

write_new_kv's first operation is a blocking device-to-host readback of
block_table (Tensor::to_vec2) followed by a host-side loop and a fresh
Tensor::from_vec upload of the resulting scatter indices — both of which
are invalid on a stream mid-capture. Left unfixed, a capture either fails
outright or (worse) silently freezes the scatter destination to whatever
block_table contained at capture time, while the K/V values keep
updating correctly on replay — silently misplacing every subsequent decode
step's KV into the position captured at step one.

Fixes this with the same pattern as set_decode_position:

impl Cache {
    /// Attaches a persistent, caller-owned device tensor of flat scatter
    /// indices (shape `(b_sz,)`) for one layer's `PagedKvCache::write_new_kv`
    /// decode step. When attached, `write_new_kv` scatters directly against
    /// it instead of deriving indices from a host readback of `block_table`.
    /// Scoped to the decode step only (`seq_len == 1`).
    pub fn set_paged_kv_decode_slot(&mut self, block_idx: usize, indices: Tensor) -> Result<()>;
    pub fn clear_paged_kv_decode_slot(&mut self, block_idx: usize);
    pub fn paged_kv_decode_slot(&self, block_idx: usize) -> Option<&Tensor>;
}

The caller updates the attached tensor's contents in place (e.g. via
Tensor::slice_set) before each CudaGraph::replay(); its identity/address
stays fixed across replays, which is what makes the capture valid.

Scope / compatibility

Everything here is additive:

• Cache::new and every existing caller of the contiguous KV path are
  unaffected — no behavior change, no new required arguments.
• set_paged_kv, set_decode_position, and set_paged_kv_decode_slot all
  default to None per layer; a layer only routes through the new paths
  once a caller explicitly attaches the corresponding tensor.
• Prefill (seq_len > 1) always uses the existing paths unconditionally;
  the position/decode-slot seams are rejected (return Err) if attached to
  a multi-token call, rather than silently producing wrong output.

Testing

• cargo fmt, cargo clippy --lib --tests -- -D warnings (candle-core,
  candle-nn, candle-transformers).
• cargo test (candle-core, candle-nn, candle-transformers): CPU-only unit
  tests, including numerical equivalence between the new device-tensor
  paths and the existing host-derived paths for the same position/indices,
  and rejection of malformed/prefill input on each new seam.
• GPU tests (--features cuda,flash-attn, dispatched on a CUDA runner):
  • paged_attention_matches_dense_causal_attention_on_gpu: paged path
    matches the dense causal-attention reference.
  • decode_position_stays_correct_across_cuda_graph_replay: captures a
    decode-step rotary lookup in a real CudaGraph, replays it, updates the
    attached position tensor's contents in place, replays again, and
    asserts the output tracks the new position rather than the one live at
    capture time.
  • paged_kv_decode_slot_stays_correct_across_cuda_graph_replay: same
    property for the paged KV scatter destination — captures
    PagedKvCache::write_new_kv's decode-step scatter, replays, updates the
    decode-slot tensor's contents in place, replays again, and asserts the
    scatter lands at the new slot.

Closes #3732