Add a Path class

[Yvee1]

I am interested in having a Path class in cartocrow that captures SVG's <path>, Qt's QPainterPath, and ipe's Path.
Here I would like to discuss ways of implementing this.

The approach currently in my mind is the following.
We need a notion of a segment, say GSegment that is an abstract class or a typedef to std::variant (Segment is already used by CGAL for line segments). Line segments, Bézier curves, and circular arcs are in some sense an instance of a GSegment.
Then we would need a notion of a curve that consists of segments, say a Curve class. A Curve is simply a sequence of GSegments that is continuous (end and start point of consecutive segments coincide), and can be open or closed (may be implicit / detected automatically).
Lastly, we have a notion of a path, say a Path class, that consists of curves. A Path is a set of Curves.

Code skeleton sketch

template <class K, class CK> GSegment = std::variant<Segment<K>, Circular_arc<CK>, BezierCurve>

template <class K, class CK> class Curve {
  private:
    std::vector<GSegment<K, CK>> m_segments;

  public:
    Curve() = default;
    void appendGSegment(GSegment<K, CK> s);
    void moveTo(Point<K> p);
    void lineTo(Point<K> p);
    void arcTo(Point<K> ...);
    void quadTo(...);
    void cubicTo(...);
}

template <class K, class CK> class Path {
  private:
    std::vector<Curve<K, CK>> m_curves;
  
  public:
    Path() = default;
    void addCurve(Curve<K, CK> curve);
    
    template <class Geometry>
    void addGeometry(Geometry g) {
        m_curves.push_back(g.toCurve());
    }
}

Besides the above, other things that need to be done for this:

• Add type alias for CGAL's Circular_arc_2.
• Implement toCurve() method for polygons, polylines, circles, Bézier spline.
• Implement toPath() method polygon with holes, and polygon set.
• Implement Qt and ipe rendering of segments, curves, and paths.
• The rendering could be refactored such that e.g. the renderer.draw(Polygon...) function implementation converts the polygon into a curve and draws the curve as these functions would need to be implemented anyway and this reduces redundancy.