Adding support for scenerio paths across representative periods #107

There has surfaced a need to better handle operational scenarios across representative periods, e.g. where scenarios represent samples from the same weather year in a consistent manner across representative periods. There is also a need to be more explicit about how constraints across representative periods is handled, e.g. yearly emission restrictions. A related discussion has also been raised in OpenEMPIRE work (ntnuiotenergy/OpenEMPIRE.jl#41).
Ongoing work on automatic decomposition could also need better handling of this, to open up for decomposition e.g. for a weather year.

There is several ways this can be handled and I have explored one of the possibilities (using Claude to prototype). See the branch https://github.com/sintefore/TimeStruct.jl/tree/tf/scenario-paths.

This approach is non-breaking with the existing time structures, but allows RepresentativePeriods to have a scenario pairing that describes how operational scenarios are to be paired when generating the possible scenario paths. The new function scenario_paths returns joint scenario paths, where each path selects one operational scenario per representative period and has an id and a probability. Here is an example using the method diagonal pairing where scenarios are combined based on their index

day = SimpleTimes(24,1)
oscens = OperationalScenarios(5, fill(day, 5), [0.3, 0.3, 0.2, 0.2])
periods = RepresentativePeriods(4, 365, oscens; pairing = DiagonalPairing())
paths = scenario_paths(periods)
prb = probability.(paths)

This would allow for e.g. upholding constraints for each scenario path, in expectation or in a more complex probabilistic sense (e.g. CVaR).

# Indivdual paths (robust)
for path in scenario_paths(periods)
  @constraint(model, sum(emisssion[t] for t in path) <= limit)) 
end

# Expectation
@constraint(model, sum(probability(path) * sum(emission[t] for t in path) for path in paths) <= limit

The tutorial section in the branch has a more complete example (and also scales thing with multiple and duration correctly).

The pairing of scenarios can also be generated in more complex ways and provided explicitly to TimeStruct. I think this is functionality that should reside outside TimeStruct, so I have created a small example package (https://github.com/trulsf/ScenarioGeneration.jl) that showcases some possibilities.

There are clearly things that need to be ironed out and API designs to be discussed, but the overall question is: should we explore this design further and is it something that should reside in TimeStruct at all (is a separate package for all of this better)? Are there better ways to handle this (e.g. allowing flexible nesting of operational scenarios and representative periods)?
@hellemo @JulStraus