Layer instantiator

It would be useful to have some kind of layer API so that the user could just do:
```julia
model = Model(MOI.layers(POI.Optimizer, HiGHS.Optimizer)
```
The challenge is the need to automatically add `CachingOptimizer` when needed. We could also automatically detected the needed coefficient type but I think for now, we can require the user to explicitly use `{Float32}` at each layer if he chooses to not use `Float64`.

It is challenging to find the right interface for this because it's quite complicated. But for the same reason, combining the layers is very difficult for our users and the errors are quite cryptic. So I think we should make the effort to find something that works and make the layers plug&play

### Current issues

## Bridge layers

Bridge layers don't create index maps for efficiency reason. What they do is use negative indices for the constraint that are bridged. This means that you cannot stack two bridge layers without a CachingOptimizer in between. I remember @chriscoey and @lkapelevich being hit by this bug when stacking `SingleBridgeOptimizer` layers on top of Hypatia. @GiovanniKarra was also hit by this issue with `SingleBridgeOptimizer`. I also got hit by this recently in https://github.com/blegat/ComplementOpt.jl/pull/29 because `ComplementOpt.Optimizer` is a subtype of `AbstractBridgeOptimizer` and `MOI.instantiate(() -> ComplementOpt.Optimizer(MOI.instantiate(Ipopt.Optimizer))` was creating a `ComplementOpt.Optimizer` layer with a `LazyBridgeOptimizer` layer directly following it so I had to explicitly create a cache in between like so: https://github.com/blegat/ComplementOpt.jl/blob/c852c0fd7016528e352a3a0b7158d611b51f0aad/test/runtests.jl#L322-L328

## Need for incremental interface

[POI needs an incremental interface](https://github.com/jump-dev/ParametricOptInterface.jl/pull/239) and bridge layers do too. So a caching optimizer should automatically be added if needed.

### Solution

The implementation would be something like
```julia
# This works for all layers of the table below
MOI.requires_incremental_interface(::Type{<:MOI.ModelLike}) = true

MOI.layers(optimizer_constructor; kws...) = MOI.instantiate(optimizer_constructor; kws...)
function MOI.layers(layer_type::Type{<:MOI.ModelLike}, args...; kws...)
model = MOI.layers(args...; kws...)
if (MOI.requires_incremental_interface(layer_type) && !MOI.supports_incremental_interface(model)) ||
(layer_type <: MOI.AbstractBridgeOptimizer && model isa MOI.AbstractBridgeOptimizer)
model = MOI.CachingOptimizer(# add a caching optimizer on top of `model`
end
return layer_type(model)
end
```
This does not completely resolves the issue with bridges. You could also have that `model` is not a bridge layer but its inner layer is a bridge optimizer and `model` does not map indices.

For a complete solution, we could have something like this that would be useful for https://github.com/jump-dev/JuMP.jl/issues/4014
```julia
abstract type Layer <: MOI.AbstractOptimizer end # Make `CachingOptimizer` and `AbstractBridgeOptimizer` be subtype of that
MOI.inner_optimizer(model::MOI.Layer) = model.inner # Name inner by convention ?
MOI.inner_optimizer(model::MOI.Bridges.AbstractBridgeOptimizer) = model.model
MOI.inner_optimizer(model::MOI.Utilities.CachingOptimizer) = model.Optimizer
```
Then, we add the following that should be implemented for any subtype of `MOI.Layer` (in addition to `MOI.requires_incremental_interface`)
```julia
MOI.share_indices_with_inner_optimizer(model::MOI.Layer) = MOI.supports_incremental_interface(model)
# Only exception to the above default implemention according to table below
MOI.share_indices_with_inner_optimizer(model::MOI.Utilities.CachingOptimizer) = false
```
and then the following one that shouldn't be implemented for layers, it correspond to the "index map" column in the above table
```julia
MOI.may_have_negative_indices(model::MOI.ModelLike) = false
MOI.may_have_negative_indices(model::MOI.AbstractBridgeOptimizer) = true
MOI.may_have_negative_indices(model::MOI.Layer) = MOI.share_indices_with_inner_optimizer(model) && MOI.may_have_negative_indices(MOI.inner_optimizer(model))
```
Then, we can do
```julia
function MOI.layers(layer_type::Type{<:MOI.Layer}, args...; kws...)
model = MOI.layers(args...; kws...)
if (MOI.requires_incremental_interface(layer_type) && !MOI.supports_incremental_interface(model)) ||
(layer_type <: MOI.AbstractBridgeOptimizer && MOI.may_have_negative_indices(model))
model = MOI.CachingOptimizer(# add a caching optimizer on top of `model`
end
return layer_type(model)
end
```

## Table

Let's use this issue to collect the list of layers we want to support and their particularities before we commit with a specific design.

| Layer | `supports_incremental_interface` | `requires_incremental_interface` | `share_indices_with_inner_optimizer` |
|---------|----------------|---------------------------|---------------------------|
| `CachingOptimizer` | ✓ | ✓ | ✘ |
| `AbstractBridgeOptimizer` | ✓ | ✓ | ✓ |
| [Dualization](github.com/jump-dev/Dualization.jl) | ✘ | ✓ | ✘ |
| [ParametricOptInterface](https://github.com/jump-dev/ParametricOptInterface.jl) | ✓ | ✓ | ✓ |
| [DiffOpt](https://github.com/jump-dev/DiffOpt.jl) | ✓ | ✓ | ✓ |
| [MultiObjectiveAlgorithms](https://github.com/jump-dev/MultiObjectiveAlgorithms.jl) | ✓ | ✓ | ✓ |

Given that all layers require the incremental interface anyway, maybe we can remove `requires_incremental_interface` and only add it once we have a solver that needs it so the implementation is simply
```julia
function MOI.layers(layer_type::Type{<:MOI.Layer}, args...; kws...)
model = MOI.layers(args...; kws...)
if !MOI.supports_incremental_interface(model) ||
(layer_type <: MOI.AbstractBridgeOptimizer && MOI.may_have_negative_indices(model))
model = MOI.CachingOptimizer(# add a caching optimizer on top of `model`
end
return layer_type(model)
end
```