The sweep is now based on `LineSegment` instead of `LineString` as it is a bit easer to work with and avoids some of the
cost associated with `Geometry`.

The intersection check for whether to include a blocking segments is now against the vision bounding box rather than the
precise vision geometry. There is a tradeoff here as more segments can be excluded the more precise we are, but in
practice the extra precision does not gain us nearly as much as it costs.

`VisibilityProblem` is now responsible for collecting and organizing segments. `VisionBlockingAccumulator` only decides
how to treat each topology type, but otherwise forwards to `VisibilityProblem`. This avoids some expense around building
large lists of segments.

A new `EndpointSet` class is responsible for maintaining the endpoints and walls for the visibility sweep. It avoids any
use of endpoint hashing in favour of retroactively merging the few duplicated endpoints we
receive. `VisibilitySweepEndpoint` now references other `VisibilitySweepEndpoint` to define walls instead of using
`LineSegment`, which saves on some redundancy and make it really easy to validate the graph.

This change moves much closer to Asano's original algorithm as described in section 3.2 of "Efficient Computation of
Visibility Polygons" ([arXiv:1403.3905](https://arxiv.org/abs/1403.3905)). The critical difference is in how we find the
nearest wall, in particular:
1. Keeping the open walls ordered by distance to the origin, so that the nearest one is always at the front.
2. Using a cheaper orientation-based comparator for the open walls that does not depend on any finding any
   intersections.

Since we don't have to intersect walls in order to find the nearest one, we can now limit ourselves to a single nearest
wall check per iteration, as opposed to the two that used to be used. Intersections are only calculated when we need to
add a point to the result that does not lie on one of the input endpoints.

There are plenty of cases where a wall is completely hidden behind other open walls and therefore cannot contribute to
the result. Instead of marking these as open, we can skip them completely and avoid a lot of expense during the sweep.

In order to keep the check cheap, walls are only checked against the nearest wall, not against all open walls that might
hide them.

A lot of things have been documented, names improved, and `VisibilityProblem` has been rearraanged to keep the core
public stuff first. There are also fewer assumptions and `assert` checks made in several places, instead opting for
being able to handle a wider variety of situations. If the sweep ever fails, an exception is thrown rather than
returning a null (no blocking) result - `FogUtil` handles this and simply does not expose any area in this case while
logging the error.

The new comparator is based on point orientation around the origin rather than directly depending on angle. This is much
cheaper, and means we don't have to cache calculations on `VisibilitySweepEndpoint` thus making it simpler.

`EndpointSet` also buckets endpoints according to which eighth of the plane the point is in. Sorting can be done on one
bucket at a time which reduces the number of comparisons needed. The buckets also remove the need for some special cases
in the comparator, further streamlining the sort.