Strategy::Frag panics with a subtract overflow on the i16 engine #88

use i_float::int::point::IntPoint;
use i_overlay::core::fill_rule::FillRule;
use i_overlay::core::overlay::Overlay;
use i_overlay::core::overlay_rule::OverlayRule;
use i_overlay::core::solver::{Solver, Strategy};

const PTS: [(i32, i32); 3] = [(0, 0), (0, 9854), (129, -23169)];

fn main() {
    let c32: Vec<Vec<IntPoint<i32>>> =
        vec![PTS.iter().map(|&(x, y)| IntPoint::new(x, y)).collect()];
    let c16: Vec<Vec<IntPoint<i16>>> =
        vec![PTS.iter().map(|&(x, y)| IntPoint::new(x as i16, y as i16)).collect()];

    for (name, strategy) in [
        ("List", Strategy::List),
        ("Tree", Strategy::Tree),
        ("Auto", Strategy::Auto),
        ("Frag", Strategy::Frag),
    ] {
        let solver = Solver { strategy, ..Default::default() };

        let r = Overlay::<i32>::with_contours_custom(&c32, &[], Default::default(), solver)
            .overlay(OverlayRule::Subject, FillRule::EvenOdd);
        let pts: Vec<Vec<(i32, i32)>> =
            r.iter().flatten().map(|c| c.iter().map(|p| (p.x, p.y)).collect()).collect();
        println!("i32 engine, {}: {:?}", name, pts);

        let r = Overlay::<i16>::with_contours_custom(&c16, &[], Default::default(), solver)
            .overlay(OverlayRule::Subject, FillRule::EvenOdd);
        let pts: Vec<Vec<(i16, i16)>> =
            r.iter().flatten().map(|c| c.iter().map(|p| (p.x, p.y)).collect()).collect();
        println!("i16 engine, {}: {:?}", name, pts);
    }
}