Load checkpoint onto CPU to avoid duplicating the model in VRAM

[tlancaster6]

Problem

RoMaV2.__init__ fetches the ~1 GB checkpoint with map_location=device:

weights = torch.hub.load_state_dict_from_url(
    ".../v2.0.1/romav2.0.1.pt",
    map_location=device,
)
...
self.to(device)          # module -> device
...
self.load_state_dict(weights)

On CUDA this materializes the entire state dict in VRAM. By the time
load_state_dict runs, self.to(device) has already moved the module, so two
complete copies of the model are resident simultaneously.

This costs twice. The obvious cost is the initialization peak. The subtler and
more damaging one is that after weights is freed, the caching allocator
retains roughly a gigabyte of reserved-but-unallocated arena for the lifetime
of the process, which later blocks large contiguous allocations.

Fix

Stage the checkpoint on CPU. This is equivalent: load_state_dict copies each
tensor into the already-placed parameters, and self.to(device) continues to
handle placement for CUDA, MPS and CPU alike. device is still used elsewhere
in the module, so the import is unaffected.

Initialization memory

RTX 4070 Ti (12 GB), precise, anchor 512, torch 2.5.1+cu121:

	peak allocated	peak reserved	resident after init
map_location=device (current)	2211.4 MiB	2296.0 MiB	1048.9 MiB
map_location="cpu" (this PR)	1162.2 MiB	1228.0 MiB	1047.6 MiB

1049 MiB less peak allocation, resident memory unchanged.

Equivalence

The resulting model is bit-identical. SHA256 over all 907 state-dict tensors
(425,510,400 elements), computed after construction on each path:

5dc2886d894fc472468fd4323ebc1dc287e7f59404fa5d640c5ebcb65d0a9717   # map_location=device
5dc2886d894fc472468fd4323ebc1dc287e7f59404fa5d640c5ebcb65d0a9717   # map_location="cpu"

End-to-end effect

Same machine, same two-frame dense-matching workload, only this line differing.
On v2.0.1 as it stands, the second frame dies inside local_correlation:

File "romav2/refiner.py", line 175, in forward
  local_corr = local_correlation(
File "romav2/local_correlation.py", line 74, in native_torch_local_corr
  (feature0[_, ..., None] / (c**0.5) * window_feature)
torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 3.59 GiB.
GPU 0 has a total capacity of 11.72 GiB of which 3.61 GiB is free.
Of the allocated memory 6.50 GiB is allocated by PyTorch, and 1.15 GiB is
reserved by PyTorch but unallocated.

3.61 GiB free, 3.59 GiB requested, and it still fails — the 1.15 GiB of
reserved-but-unallocated arena is the freed checkpoint copy, and it is enough
fragmentation to break the request. With map_location="cpu" the same
allocation succeeds and both frames reconstruct.

	frames reconstructed
map_location=device	1/2
map_location="cpu"	2/2