Replace KeyMaterial .allow_hazardous_operations() with a closure-based solution

[ounsworth]

Basic idea:

 fn do_hazardous_operations<F>(&mut self, mut f: F) -> Result<(), KeyMaterialError>
 where
       F: FnMut(&mut Self) -> Result<(), KeyMaterialError>,
        Self: Sized,
    {
        self.allow_hazardous_operations();
        let ret = f(self);
        self.drop_hazardous_operations();
        ret
    }
 }

And then applications can call it like:

        key.do_hazardous_operations(|key| {
            rng.next_bytes_out(&mut key.mut_ref_to_bytes().unwrap())
                .map_err(|_| KeyMaterialError::GenericError("RNG failed."))?;

            key.key_len = KEY_LEN;
            key.key_type = KeyType::BytesFullEntropy;
            key.security_strength = rng.security_strength();

            Ok(())
        })?;

[npajkovsky]

Just a side note. The do_hazardous_operations() explicitly set/unset allow_hazardous_operations because of pattern

    fn set_key_len(&mut self, key_len: usize) -> Result<(), KeyMaterialError> {
        if !self.allow_hazardous_operations {
            return Err(KeyMaterialError::HazardousOperationNotPermitted);
        }
        if key_len > KEY_LEN {
            return Err(KeyMaterialError::InvalidLength);
        }
        self.key_len = key_len;
        Ok(())
    }

set_key_len() if you want to use hazard ops, you must route the function via callback; otherwise, it will return an error. In such a case, updating doc is just enough.