Consider adding universal `get`ter methods for process types

[bgroenks96]

We could define a universal getter like:

get_process(coupled_processes, AbstractEvapotranspiration)

to avoid the boilerplate of every AbstractCoupledProcesses subtype needing to define a series of get_* methods, similar to what was previously done for models.

This could take advantage of the fact that the processes method provides compile-time information about process types defined on any model or coupled processes type.

Alternatively, we could generate such methods for all AbstractCoupledProcesses types semi-automatically using macros.

However, this is also one of those situations where we would trade transparency for a relatively minor reduction in boilerplate. Sometimes boilerplate is good for clarity and simplicity :)

Also LLMs are good at generating boilerplate code, so one could also ask: why bother?

@maximilian-gelbrecht Following up on discussion in #68

[maximilian-gelbrecht]

Yeah, I also think it's best to not overthink this and when we are bothered by this we can let an LLM write this boilerplate code.

I also quickly tried to come up with a suitable @generated / @eval function (with Claude's help), I am not super happy with it, but it works. Not sure we really want it though.

"""
    generate_all_getters()

For each abstract subtype `T` of `AbstractCoupledProcesses`, collect all `AbstractProcess`-typed
field names from concrete subtypes of `T` and define `get_<fieldname>(obj::T)` getter functions.
This should be called once at the end of the module, after all types have been defined.
"""
function generate_all_getters()
    for T in InteractiveUtils.subtypes(AbstractCoupledProcesses)
        names = Set{Symbol}()
        _collect_process_fieldnames!(names, T)
        for name in names
            getter = Symbol(:get_, name)
            @eval @inline $getter(obj::$T) = getfield(obj, $(QuoteNode(name)))
        end
    end
    return nothing
end

function _collect_process_fieldnames!(names::Set{Symbol}, @nospecialize(T::Type))
    if !isabstracttype(T)
        for (name, type) in zip(fieldnames(T), fieldtypes(T))
            type <: AbstractProcess && push!(names, name)
        end
    end
    for ST in InteractiveUtils.subtypes(T)
        _collect_process_fieldnames!(names, ST)
    end
end