[API breaking] Use polymorphic value type holder for manifolds and constraint sets

[ManifoldFR]

This PR:

• removes use of shared_ptr for manifold and constraint set types, switching to jbcoe/value_types's polymorphic template class everywhere as a holder with value semantics
• enhances the library's ergonomics by avoiding having to call std::make_shared<T>(...) all the time, see changed C++ examples
• updates the examples and tests accordingly
• adds a util header proxsuite-nlp/python/polymorphic.hpp for dealing with values/references of polymorphic<T>, register conversions, etc
• updates Python bindings for manifolds and constraint sets accordingly
• adds a PolymorphicVisitor to the Python bindings which registers a type Y as convertible to the template argument polymorphic<X>
• splits up the big constraint instantiation header constraints.txx: closes Template instantiation: split up constraints.hpp and constraints.txx mega-headers #87

Known issues

• returning a polymorphic<X> by value does not check whether the underlying object is a boost::python::wrapper<U> for some type U which inherits from X
• this PR is a breaking change for proxsuite-nlp's C++ API

Background

This is the first in a series of PR which will cut down on our overuse of shared_ptr across both proxsuite-nlp and aligator and replace it with a holder for polymorphic objects with value semantics.

The drawbacks to the current approach with shared_ptr was:

• no real copy constructor for shared_ptr<T>, except if we add virtual clone member functions implemented in all derived classes
• calls to members did not satisfy const-correctness (not a problem for manifolds as they so far have no non-const member functions, but a problem for namely BoxConstraint)
• shared mutable state

The polymorphic value type was described by Jonathan Coe: https://www.youtube.com/watch?v=sjLRX4WMvlU. It allows composite classes (with polymorphic data members) to behave well using value-semantics all the way down (with const-correctness).

Why not unique_ptr ?

unique_ptr completely removes any ability to copy the underlying object (except if a virtual clone() was implemented) and disables default copy ctor/operators for all composite classes using it.

Many thanks to @edantec for his contribution.

[ManifoldFR]

The last thing to do before merging, which is very relevant for downstream integration into aligator, is being able to extend interfaces from Python. Right now, inheriting from bp::wrapper<PythonClass> and using the current macros doesn't seem to work anymore. We need to:

• add this case to the test
• find a way to fix this. AFAIK, for shared_ptr<T>, Boost.Python handles calling virtual methods implemented in Python by fetching a pointer to the Python object that is hidden in the deleter - this reference to the PyObject* is injected by the shared_ptr holder

[edantec]

After quick glance, PR seems ok

[ManifoldFR]

@jorisv @edantec I think Windows is finally fixed (my god...)

[ManifoldFR]

While discussing with @jorisv, we found that:

• passing the wrapper class to a function/ctor taking polymorphic<T> does not properly copy the object
• by properly copying, we mean that the reference to the initial object is not properly handled, there's a missing incref somewhere
• in Boost.Python, the converter class shared_ptr_from_python, which is registered in the class_metadata.hpp header, takes the source PyObject* (see here), borrows it with bp::borrowed (which casts it to a pointer to the special type bp::detail::borrowed<PyObject> (see boost/python/detail/borrowed_ptr.hpp)), and shoves it into a bp::handle<> object, the constructor of which increfs the pointer to borrowed and upcasts it back to PyObject to store it (see here)

[ManifoldFR]

Okay, we will be merging this today. This is not the perfect solution imo, I'd be willing to look at other types of type erasure in the future for the definitive API (and rip out the OOP class hierarchies here and in aligator, downstream).
Having value semantics is already good enough though and we can make progress on other fronts.