Add new handler trait with better abstraction

[NickCondron]

The usability of event-based parsing is hindered by the Handlers trait functioning at the event-level. This means any implementer has to worry about rollbacks, frame data duplication after character elimination, and handling all sorts of errors. Right now this issue is blocking my progress on stats. I propose to rename Handlers to EventHandler and create a new trait GameHandler

pub trait GameHandler {
    fn game_start(&mut self, _: game::Start) { }
    fn frame<const N: usize>(&mut self, _: Frame<N>) { }
    fn game_end(&mut self, _: game::End) { }
    fn metadata(&mut self, _: Metadata) { }
    fn finalize(&mut self) { }
}

Also a struct Hook that wraps a GameHandler and handles all the events feeding the GameHandler as frames are finalized.

pub struct Hook<H> where H: GameHandler {
    hook: H,
    // ...
}

impl<H> EventHandler for Hook<H> where H: GameHandler { /* ... */ }

That way a user can parse with code like this:

struct DoWhatIWant;
impl GameHandler for DoWhatIWant {
    fn frame<const N: usize>(&mut self, frame: frame::Frame<N>) {
        println!("{:?}", frame);
    }
}

let mut buf = BufReader::new(File::open("game.slp").unwrap());
let mut hook = Hook::new(DoWhatIWant);
peppi::parse(&mut buf, &mut hook, None).unwrap();

This PR is a nearly finished. TODO:

• ~Add option for Rollback publishing. Right now it only publishes frames that are finalized (ie. can no longer be rolled back).~ DONE
• ~Re-implement Collector in terms of the new trait. We'd need to understand the performance impacts and this would be a good test for speed/correctness. If Collector can use the higher-level abstraction without performance problems, we could consider replacing the Handlers trait altogether~ DONE -- performance is unaffected or slightly improved
• ~Unify interface so that user only needs to care about implementing GameHandler. All things related to Hook and EventHandler can mostly be under the hood.~ DONE

Future work:

• Add a size hint function to EventHandler/GameHandler that hints the number of frames the game is expected to have in case it is known in advance (ie. read from a file). This would allow performance improvements with preallocation.
• Allow handler to indicate which parts of the game it cares about allowing the parser to scan past unneeded events (speculative idea)
• Support chaining/combining handlers -- kind of like https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.chain .
• Use some reference magic like https://docs.rs/replace_with/latest/replace_with/ to allow user to pass in reference to handler instead of an owned handler

[NickCondron]

Closing because I no longer like my solution even though it is in the right direction. I will give another attempt at this problem soon. As mentioned before the poor ergonomics of the Handlers trait is blocking the stats work and the usability of peppi more broadly.