Support Multiple Big-M reformulation.

[dnguyen227]

This PR adds the Multiple Big-M reformation technique. The technique can be called similar to BigM and Hull:

optimize!(model, gdp_method = MBM(Gurobi.Optimizer))

In src/mbm.jl are extensions for reformulate_disjunction, _reformulate_disjunct, and reformulate_disjunct_constraint functions that dispatch over the new MBM datatype.

Documentation to follow in another PR.

[pulsipher]

Overall pretty good, please generalize to work with the InfiniteOpt extension and add this to the docs.

[dnguyen227]

JuMP.Variable_ref_type ->get the type -> use that type

[dnguyen227]

This new function differs from make_disaggregated_variable(). The main difference is that instead of passing the variable attributes, I instead pass the variable itself and check for the attributes within this new function.

Why?
The alternative to this would be to have all attributes as possible inputs and default them to nothing, but then the function would still need to check if the value is 'nothing'.
For example:

function _copy_variable(
    target_model::JuMP.AbstractModel,
    original_var::JuMP.AbstractVariableRef;
    base_name::Union{String, Nothing} = nothing,
    lower_bound::Union{Float64, Nothing} = nothing,
    upper_bound::Union{Float64, Nothing} = nothing,
    start_value::Union{Float64, Nothing} = nothing,
    is_integer::Union{Bool, Nothing} = nothing,
    is_binary::Union{Bool, Nothing} = nothing,
    fixed_value::Union{Float64, Nothing} = nothing
    )
    
    # Create new variable with base name
    var_name = base_name !== nothing ? base_name : JuMP.name(original_var)
    new_var = JuMP.@variable(target_model, base_name = var_name)

    # Set attributes if provided
    lower_bound !== nothing && JuMP.set_lower_bound(new_var, lower_bound)
    upper_bound !== nothing && JuMP.set_upper_bound(new_var, upper_bound)
    start_value !== nothing && JuMP.set_start_value(new_var, start_value)
    is_integer !== nothing && is_integer && JuMP.set_integer(new_var)
    is_binary !== nothing && is_binary && JuMP.set_binary(new_var)
    
    # Handle fixed value with force=true
    if fixed_value !== nothing
        JuMP.fix(new_var, fixed_value; force=true)
    end

    return new_var
end

This involved two checks, once before passing to the function, then one inside the function. So I thought just passing the variable to limit it to one check was better.

Let me know if there is a better way to do this, especially if I can make more akin to make_disaggregated_variable.