Remove requirement of Hashing from GameState

[ValorZard]

Currently in Backroll, gamestates that get saved and loaded HAVE to be able to be hashed. This leads to a lot of issues, since important gamestate stuff like floats and vectors aren't able to be hashed. This should be replaced with something more universal.
Note: as far as I know I think this issue is with bevy_backroll but it could extend to the original backroll library as well

[ErnWong]

(Copying this from a discord conversation)

FYI, as a temporary workaround, I'm manually serializing vec2s into OrderedFloat<f32> for the fishgame backroll integration prototype.

Is the hash requirement only used for creating checksums of the state?

backroll-rs/backroll/src/command.rs

Lines 65 to 69 in 3c6bdc0

	pub fn save(self, state: T::State) {
	let mut hasher = DefaultHasher::new();
	state.hash(&mut hasher);
	self.save_with_hash(state, hasher.finish());
	}

But there's already the ability to save the state without a hash and with an explicit hash:

backroll-rs/backroll/src/command.rs

Lines 71 to 85 in 3c6bdc0

	/// Saves a single frame's state to the session's state buffer without
	/// a saved checksum.
	///
	/// This consumes the SaveState, saving multiple times is not allowed.
	pub fn save_without_hash(self, state: T::State) {
	self.save_state(state, None);
	}
	/// Saves a single frame's state to the session's state buffer with a
	/// provided checksum.
	///
	/// This consumes the SaveState, saving multiple times is not allowed.
	pub fn save_with_hash(self, state: T::State, checksum: u64) {
	self.save_state(state, Some(checksum));
	}

To remove the Hash requirement, would it be enough to conditionally implement the save method whenever Config::State impls Hash? I'm assuming that SaveState::save is not relied upon internally by backroll, but I haven't checked it thoroughly yet.

For example, something like this seems to compile.
Rust Playground

struct A<T>(std::marker::PhantomData<T>);

impl<T> A<T> {
    pub fn save(state: T) where T: std::hash::Hash {
        let mut hasher = std::collections::hash_map::DefaultHasher::new();
        state.hash(&mut hasher);
        todo!();
    }
    pub fn save_without_hash(_state: T) {
        todo!();
    }
    pub fn save_with_hash(_state: T) {
        todo!();
    }
}

[james7132]

Thought this would be harder given that Rust does not allow constraining on associated types, but turns out we just needed to restructure the generic type parameters a bit, and it does indeed work. This should be fixed as of 014fd15; however, this has led to a silent failure case show in #20. This should be fixed in some user visible way before releasing the next public version of backroll and the bevy plugin.