Fix owa() dask path and batch wpm() validation into one scheduler pass

[brendancol]

Closes #3150

• _sort_descending called da.sort, which does not exist in dask, so owa() raised AttributeError on any dask-backed Dataset. It now rechunks the criterion axis to a single chunk and sorts each block with np.sort via map_blocks (exact, since the axis lives in one chunk; memory stays bounded by block size). meta is forwarded so dask+cupy blocks keep their cupy meta.
• While testing the dask+cupy path I found the order-weights array was always numpy, which cupy kernels reject. owa() now copies the order weights to the device when the data is cupy-backed (plain or dask), so both cupy paths work instead of raising TypeError.
• _check_wpm_positive ran float(da.nanmin(arr).compute()) once per criterion, i.e. one serialized scheduler pass per layer at call time. The nanmin reductions are now collected and run through a single dask.compute() call.

Backend coverage: numpy unchanged; dask+numpy fixed (owa) and faster validation (wpm); cupy and dask+cupy owa now work and were verified on a CUDA host.

Test plan:

• pytest xrspatial/tests/test_mcda.py (182 passed, includes 7 new tests)
• New dask tests: owa parity vs numpy, owa uniform-order-weights == wlc, wpm parity, wpm single-scheduler-pass assertion, wpm non-positive rejection on dask
• New GPU tests (gated on cuda_and_cupy_available): owa cupy and dask+cupy parity, run on a CUDA host
• Graph probe: owa on 2560x2560 / 256-chunks builds ~15 tasks per chunk, no fan-in blowup

[brendancol]

PR Review: Fix owa() dask path and batch wpm() validation into one scheduler pass

Blockers (must fix before merge)

None.

Suggestions (should fix, not blocking)

• xrspatial/tests/test_mcda.py (TestOWADask): the dask tests use even 10x10 chunks only. A ragged-chunk case (e.g. chunk({"y": 7, "x": 9}) on a 20x20 grid) would catch block-alignment mistakes in the rechunk+map_blocks sort, which is exactly the code this PR adds.

Nits (optional improvements)

• xrspatial/mcda/combine.py:387 (_sort_block_descending): a one-line note that NaN ordering matches the eager -np.sort(-data) path (NaNs sort to the same end) would save the next reader from re-deriving it.

What looks good

• The per-block sort is exact because the criterion axis is rechunked into a single chunk first, and meta=data._meta keeps dask+cupy blocks typed correctly.
• The scheduler-pass regression test pins the actual behavior (one dask.compute call with all three reductions) instead of timing anything.
• The order-weights device copy fixes a second crash (plain-cupy owa) that the issue did not even cover, with parity tests on both GPU backends.

Checklist

• Algorithm matches reference (descending sort + order weights, parity vs eager path)
• All implemented backends produce consistent results (numpy/dask verified in tests; cupy/dask+cupy gated tests ran on a CUDA host)
• NaN handling is correct (NaN fixture in the dask parity test)
• Edge cases are covered by tests (non-positive rejection on dask, uniform order weights == wlc)
• Dask chunk boundaries handled correctly (axis fully contained per block)
• No premature materialization (validation now a single batched compute; sort path stays lazy)
• Benchmark exists or is not needed (no mcda benchmarks exist; not added here)
• README feature matrix: no tier changes needed (owa GPU cells already marked experimental)
• Docstrings present and accurate (helper docstrings added)

[brendancol]

Follow-up review after b-commit:

• Ragged-chunk suggestion: fixed. test_owa_dask_matches_numpy is now parametrized over even (10x10) and ragged (7x9) chunkings; both pass.
• NaN-ordering nit: fixed with a note in _sort_block_descending explaining parity with the eager -np.sort(-data) expression.

No remaining findings. 183 tests pass locally, including the GPU-gated cases on a CUDA host.