Add path-bool library (#1952)

* Add path-bool library

* Cleanup code

* Cargo format

* Integrate boolean ops into graphite

* Add test for editor crash

* Fix edge sort floating point instability

* Add unit test for red-dress failure

* Backport tests and aux functions

* Use curvature based sorting

* Convert linear cubic splines to line segments

* Deduplicate reversed path segments

* Fix epsilon for empty segments

* Remove parameter based intersection pruning

* Add support for reversed paths

* Add benchmark infrastructure

* Add intersection benchmark

* Add recursion bound

* Implement support for overlapping path segments

* Remove rouge prinln

* Fix sorting for bezier segments with one control point at the start of the segment

* Cleanup log statements

* Directly translate graphite paths to Path segments

* Round data before passing it to path_bool

* Fix flag_faces traversal order

* Add test for white dots in bottom right of painted dreams

* Make rounding configurable

* Update demo artwork to remove manual path modifications

* Convert from path segments to manipulator groups directly

* Remove dead code

* Fix clippy lints

* Replace functions in path segment with methods and add documentation

* Add more documentation

* Close subpaths

* Reorganize files and add README.md

* Add license information

* Code review

* Fix license info

* Adopt new node macro and fix demo artwork

* Close subpaths with Z

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

libraries/path-bool/src/util/math.rs

@@ -0,0 +1,23 @@
+use glam::{DVec2, FloatExt};
+pub use std::f64::consts::PI;
+
+pub fn lin_map(value: f64, in_min: f64, in_max: f64, out_min: f64, out_max: f64) -> f64 {
+	((value - in_min) / (in_max - in_min)) * (out_max - out_min) + out_min
+}
+
+pub fn lerp(a: f64, b: f64, t: f64) -> f64 {
+	a.lerp(b, t)
+}
+
+pub fn vector_angle(u: DVec2, v: DVec2) -> f64 {
+	const EPS: f64 = 1e-12;
+
+	let sign = u.x * v.y - u.y * v.x;
+
+	if sign.abs() < EPS && (u + v).length_squared() < EPS * EPS {
+		// TODO: u can be scaled
+		return PI;
+	}
+
+	sign.signum() * (u.dot(v) / (u.length() * v.length())).acos()
+}