A Forecaster built without config now silently has per_var_std=None
when its predictor doesn't output its own std. Previously per_var_std
was always computed by ForecasterModule itself, so this gap didn't
exist; now that construction is split across two calls, catch it at
ForecasterModule init instead of crashing at the first val/test step.

Each member's predicted std is its own, not a spread computed across
the ensemble, so ensemble_std was a misleading name. Document on
ProbabilisticForecaster that a per-member std makes the predictive
distribution a mixture of Gaussians, and note in
ProbabilisticARForecaster.compute_training_loss that averaging the
per-member stds is a simplification of the true mixture variance
(which also includes the spread between member means).

Co-authored-by: Joel Oskarsson <joel.oskarsson@outlook.com>

Scoring the ensemble mean with a pointwise metric only rewards the
mean being right, giving the model no incentive to keep a calibrated
spread, and risks training it to collapse to a point estimate. Redeclare
compute_training_loss as abstract on ProbabilisticARForecaster instead
of providing that as a default (it would otherwise silently fall back
to ARForecaster's single-rollout objective via MRO, not even the
ensemble mean). Concrete subclasses must define their own objective.

Tests that only need an instantiable forecaster now use a local
ConcreteProbabilisticARForecaster example (ensemble-mean scoring,
moved out of the library code); a new test locks in that the base
class itself cannot be instantiated.

Drop ProbabilisticARForecaster's ensemble_size constructor arg and the
implicit num_members=None -> self.ensemble_size fallback in
sample_ensemble; num_members is now always required. Baking a default
member count into the forecaster's state was unnecessary now that
compute_training_loss is abstract too (nothing in the shared base
class path used it) and just adds an implicit default callers could
silently rely on instead of deciding explicitly. The num_members < 1
validation moves from __init__ to sample_ensemble accordingly.
ProbabilisticForecasterModule.eval_ensemble_size follows suit: it no
longer defaults to None with a forecaster fallback, it's required.

Test-only ConcreteProbabilisticARForecaster (used wherever a concrete
probabilistic forecaster is needed for testing) gains its own
train_num_members for the training objective, since deciding how many
members to sample during training is now the concrete subclass's call.

Mirrors validation_step: samples eval_ensemble_size members and scores
the ensemble mean, same as validation. Factored the shared sampling +
scoring + logging into _ensemble_step(batch, phase) rather than
duplicating the block, since validation_step and test_step differ only
in their log-key prefix and which metrics dict collects the result.

Overrides on_test_epoch_end (rather than inheriting
ForecasterModule's) since this module's test_step doesn't populate
spatial_loss_maps or plot examples - the inherited version would crash
on torch.cat of an empty list.

Remove explanatory comments around the per_var_std overrides; the
assignments are clear on their own.

…crete deterministic/probabilistic modules

Introduce BaseForecasterModule (abstract) under models/forecasters/ holding
shared plumbing (training_step, common_step, batch standardization,
checkpoint compatibility, plotting/aggregation helpers), with
validation_step, test_step and on_test_epoch_end left abstract since they
differ meaningfully between evaluation modes. Rename ForecasterModule to
DeterministicForecasterModule and move it, alongside
ProbabilisticForecasterModule, into forecasters/ as siblings implementing
the shared contract, rather than one subclassing the other.

…aster

DeterministicForecasterModule.validation_step/test_step read
self.forecaster.loss and self.forecaster.per_var_std directly, so the
Module still knew how to compute a loss from a prediction. Add an
abstract Forecaster.score (implemented on ARForecaster) that resolves
the pred_std fallback and applies a scoring rule internally; the Module
now only calls forecaster.score(...) and never touches loss/per_var_std
itself.

…ster

BaseForecasterModule.__init__ raised if forecaster.per_var_std was None
and the forecaster didn't predict its own std -- a check on the
Forecaster's configuration living in the wrong class. Move it into
ARForecaster via a new _resolve_pred_std helper, shared by score() and
compute_training_loss(): construction with config=None now always
succeeds (a valid state for forecasters only ever used for inference),
and the ValueError instead fires from the Forecaster itself, only once
scoring is attempted without any std to use.

…dules/

BaseForecasterModule, DeterministicForecasterModule and
ProbabilisticForecasterModule (Lightning wrappers around a Forecaster)
were mixed in with the Forecaster classes themselves under
neural_lam/models/forecasters/. Move them into their own
neural_lam/models/modules/ package (base.py, deterministic.py,
probabilistic.py) so the two concerns: what a forecaster is vs how
it's trained/evaluated by Lightning live in separate directories.
Pure move: internal imports and neural_lam/models/__init__.py updated
accordingly, no behavioural change.

Resolves the conflict on neural_lam/models/module.py: main's PR mllam#675
added --train_steps_to_log and deduplicated the val/test/train
prediction+loss+logging pattern into _compute_prediction_and_loss /
_log_step_loss, on top of the pre-mllam#700 module.py where the Module
still owned self.loss/self.per_var_std directly. This branch had since
deleted that file (split into modules/base.py, deterministic.py,
probabilistic.py, with loss ownership moved onto the Forecaster).

Ports mllam#675's dedup/logging helpers (_warn_skipped_steps, _log_step_loss,
the train_steps_to_log hparam) into modules/base.py, and rewires
DeterministicForecasterModule's validation_step/test_step to use them
via forecaster.score() instead of the removed self.loss/self.per_var_std.
_compute_prediction_and_loss is dropped rather than ported: it assumes a
single per-step-decomposable loss, which conflicts with
compute_training_loss's contract that a forecaster's training objective
may not decompose per step (e.g. an ELBO). training_step therefore still
only logs the aggregate train_loss; train_steps_to_log is accepted for
CLI/checkpoint compatibility but does not yet produce a
train_loss_unroll{i} breakdown -- documented inline as a deliberate
scope boundary, not an oversight.

Also fixes two call sites (deterministic.py, probabilistic.py) that
referenced the pre-rename _warn_skipped_val_steps, and absorbs the
unrelated utils.py -> utils/ package split from mllam#682 (auto-merged
cleanly, this branch never touched utils.py).