Unify interface for decompose and overapproximate

[schillic]

decompose basically calls overapproximate from a loop. Whenever we add a new overapproximate implementation, we also need to manually add a new implementation for decompose as well to support it there. Can we find a way to automate this process?
Maybe with macros?
Maybe by using the idea from #339 to only use Symbols as parameters and then determining the correct overapproximate function dynamically? Will this be efficient?

[mforets]

decompose's signature is:

function decompose(S::LazySet{N};
                   set_type::Type{<:Union{HPolygon, Hyperrectangle, Interval}}=Hyperrectangle,
                   ε::Real=Inf,
                   blocks::AbstractVector{Int}=default_block_structure(S, set_type),
                   block_types=Dict{Type{<:LazySet}, AbstractVector{<:AbstractVector{Int}}}(),
                   directions::Union{Type{<:AbstractDirections}, Void}=nothing
                  )::CartesianProductArray where {N<:Real}

Here, set_type is the target set type. Suppose that we generalize this to set_type::Type{<:LazySet}=Hyperrectangle,, isn't this what is needed to make it general? It ultimately depends on project being defined for such target type.

[schillic]

One idea is to have a new struct that wraps all those options instead and decides which analysis is performed. There should also be a to-string function that prints the resulting action, like "use set type $set_type".

[schillic]

These options can be distinguished by their type. Hence we could at least offer a general constructor that only takes one argument.

[schillic]

I would argue that the decompose interface is now much simpler and there is no need for this anymore.