…int error on buffer_with_style test

Replace a manual validity check on MultiPolygon, which was iterating on
each polygon combination, by a direct call of GEOSisValid.

…created SweeplineIntersector class to compute intersections on groups of segments.

Segment#segment_intersection sligtly modifies the code from intersects_segment? and actually computes the intersection point (or nil if none).
Edge cases for colinear segments are handled by return a single point from the intersection.
intersects_segment? was modified to just check if segment_intersection is not nil.

A SweeplineIntersector class was added that uses a basic sweepline algorithm to compute the intersections in a set of segments.
This should be faster or as fast as the current validate_geometry intersection algorithm being used (more testing needed), since
it only compares segments where their y-range includes the y value of the event the sweepline is handling.
There are options to return all intersections or proper intersections that will filter out the connections in LineStrings.

In the future, it is possible to make a Sweepline class and have the SweeplineIntersector inherit from it. This would allow
us to use the sweepline more generically in other applications (some polygon clipping algos use a sweepline).

…rved_segments with Set, condense event creation branching.

Adds a PlanarGraph implementation based on a Doubly Connected Edge List (DCEL). A DCEL is a graph data structure of
vertices and half-edges. Half-edges are directed edges where one segment can be represented by a pair of half-edges.
Half-edges are linked so that faces can be traversed (although faces are not stored).

The PlanarGraph accepts an array of segments to build it and additional edges can be added via the add_edge and add_edges methods.
When edges are added, intersections are automatically recomputed and handled. When possible, existing half-edges are preserved
so that geometries can reference those half-edges.

Also adds GeometryGraph which is a convenient way to interface geometries to a planar graph and provides ways to find important
half-edges in each geometry.

I haven't done a full performance test yet, but one notable area of improvement is that everytime an edge or edges is added,
all of the half-edges are re-linked when we likely only need to re-link the half-edges that originate at new vertices.

…d class in GeometryGraph

…alfEdge and Cartesian::GeometryGraph

… if no block is given

…idity checking of geometries.

The ValidOp module provides methods based on simple geometric predicates to determine validity for a geometry and can be used as a fallback or overridden.
The module can be overriden fully (in the case of Cartesian polygons) or just by implementing #invalid_reason (FFI and CAPI factories).

Removes #validate_geometry from all classes and replaces them with #prepare_geometry. Any required validations were moved to the constructors.

Adds the ValidityTest module to test/common to ensure that all classes of geometries validate in the same way.

…ommon module

ValidOp is to be included in feature classes and has the invalid_reason and valid? methods, as well as feature type specific methods that walk through the validity flow for each
geometry type.

ValidOpHelpers is a collection of functions where an object is passed to them. These perform the specific checks and return the invalid reason if applicable.

Also added overrides for both modules for cartesian functions.

…nd fix tests, ValidOp so the spherical factory passes validity checks

Co-authored-by: Keith Doggett <keith.doggett887@gmail.com>

I've added our `.yardopts` to make sure our options are used by
rubydoc.info

I've made examples point images to github to be sure we always see an
image, wether we're on rubydoc or github.

Completed TODOs.

Added Klaxit to the gallery :)

(1) `make_valid` should raise when it cannot produce a geometry, not
    return nil.

(2) +, -, * operator methods would generate uncallable `unsafe_+`
    methods, hence we alias those with text.