Add precise registry types and allocation-free queries and updates

[kennykerr]

This update replaces some of the internals of the windows-registry crate to make it easier to query and update values with precise registry types and supports allocation-free queries and updates.

Bytes can now be written with an explicit registry type:

key.set_bytes("other", Type::Other(1234), &[1, 2, 3, 4])?;
assert_eq!(key.get_type("other")?, Type::Other(1234));

Values can be read without dictating their type ahead of time:

let value = key.get_value("other")?;
assert_eq!(value.ty(), Type::Other(1234));
assert_eq!(*value, [1, 2, 3, 4]);

Expand strings are directly supported:

key.set_expand_hstring("expand_hstring", h!("value"))?;
assert_eq!(key.get_type("expand_hstring")?, Type::ExpandString);
assert_eq!(key.get_hstring("expand_hstring")?, "value");

Allocation-free queries and updates can be performed using the unsafe "raw" methods:

key.raw_set_bytes(w!("raw"), Type::Other(1234), &[1, 2, 3])?;

let (ty, len) = key.raw_get_info(w!("raw"))?;
assert_eq!(ty, Type::Other(1234));
assert_eq!(len, 3);

let mut bytes = [0; 3];
key.raw_get_bytes(w!("raw"), &mut bytes)?;
assert_eq!(bytes, [1, 2, 3]);

These raw methods are used internally by all of the safe methods and are available if your needs exceed what is offered by the safe methods.

The Value type can now hold any registry value, known or unknown:

let mut value = Value::try_from("expand")?;
value.set_ty(Type::ExpandString);
assert_eq!(value.ty(), Type::ExpandString);
key.set_value("expand", &value)?;
assert_eq!(key.get_type("expand")?, Type::ExpandString);
assert_eq!(key.get_value("expand")?, value);
assert_eq!(key.get_string("expand")?, "expand");

Fixes: #3148

[riverar]

Thanks for the work on this, looks great!

I only have a few concerns regarding the potential confusion around Registry keys containing Registry values--name/data pairs--and the impact this is having on the API design or usability.