Introduce Deterministic Frame Map-Reduce Execution for Scalable LevelDAG Processing

[harryswift01]

Summary

This PR refactors the hierarchy-level frame execution pathway into a deterministic frame/chunk map-reduce architecture.

The main purpose is to separate workflow orchestration from frame execution, Dask scheduling, worker task construction, and parent-side reduction. LevelDAG now owns the high-level workflow order, while the new levels.execution package owns chunking, scheduling, worker-side frame tasks, and deterministic reduction of covariance and neighbour outputs.

This PR also moves frame-dependent neighbour counting into the frame/chunk execution path, so each frame task now computes both covariance and neighbour-count contributions. Conformational/dihedral map-reduce is intentionally left for a follow-up PR.

Changes

Add frame map-reduce execution layer:

• Added a new CodeEntropy.levels.execution package for frame execution infrastructure.
• Added deterministic frame chunking via chunk_frame_indices.
• Added ExecutionPolicy to keep chunk size and in-flight task limits internal.
• Added FrameScheduler to choose between serial execution and Dask execution.
• Added bounded Dask frame-chunk submission with deterministic chunk-order reduction.
• Added compact worker task/result types for frame-chunk execution.

Move reduction out of LevelDAG:

• Moved covariance reduction logic into CovarianceReducer.
• Moved neighbour total/sample reduction into NeighborReducer.
• Added stable key ordering for deterministic parent-side reductions.
• Added merge helpers for combining frame-level and chunk-level running means.
• Removed frame reduction, Dask submission, and worker payload construction responsibilities from LevelDAG.

Move neighbour counts into the frame path:

• Replaced trajectory-wide neighbour averaging with frame-local neighbour-count payloads.
• Added per-frame neighbour totals and sample counts as mergeable map outputs.
• Kept symmetry number and linearity calculation as static metadata because they do not vary by frame.
• Final neighbour averages are now computed after all frame/chunk outputs have been reduced.

Simplify LevelDAG and FrameGraph responsibilities:

• LevelDAG now focuses on static setup, neighbour metadata initialisation, frame-stage delegation, and finalisation.
• FrameGraph now only owns frame-local DAG execution and trajectory positioning.
• Removed old LevelDAG private helpers for Dask execution and covariance reduction.
• Removed the static neighbour node from the static DAG.

Update tests and documentation:

• Added atomic unit tests for the new execution modules.
• Updated tests to reflect the new ownership boundaries.
• Added/updated Google-style docstrings across the refactored frame execution modules.
• Preserved the existing conformational state output contract.

Impact

• Makes the frame execution architecture easier to reason about and test.
• Reduces LevelDAG complexity by moving low-level execution and reduction details into dedicated modules.
• Enables scalable frame/chunk execution for serial and Dask workflows.
• Moves neighbour counting into the frame-parallel path, increasing the useful work performed per frame task.
• Keeps parent-side reductions deterministic even when Dask futures complete out of order.
• Provides infrastructure for a future conformational/dihedral map-reduce refactor.
• Keeps conformational analysis in the static stage for now to avoid mixing a larger multi-pass refactor into this PR.
• Preserves existing scientific output contracts while improving execution structure.

[jimboid]

This PR brings a necessary refactor to enable further enhancements to the parallel execution model. The PR is complete with the required code changes, docs and unit tests completed in one pass. The regression tests have not changed which is a very healthy sign that the changes brought here, although extensive are still delivering the same scientific outputs.