A `#![no_std]` crate containing types for encapsulating unaligned values.

The primary type this crate provides is `Unaligned<T>`, which stores a value of type `T` unaligned. 
Storing values unaligned can be an alternative to using `#[repr(packed)]` structs (which can only be used
unsafely) or carefully-sized byte arrays. The `Unaligned<T>` type exposes a safe mutable API for working
with unaligned values, while the companion type `UnalignedCell<T>` is an interior mutability type that
provides a shared mutable API for working with unaligned values.

Because references are required to be aligned, it is unsafe to take a reference to a potentially unaligned value.
The `Unaligned<T>` type therefore encapsulates the unaligned-ness of the value, letting code take (safe) references
to `Unaligned<T>`. It also provides safe mutable APIs to set, replace, and access the value without taking an unaligned
reference.

Note that, in general, a safe *shared* API is not possible for unaligned values, because in order to do anything useful
with an unaligned value, the value must be moved into aligned storage - an inherently exclusive operation. The
`UnalignedCell<T>` type somewhat alleviates this restriction by allowing exclusive access through a shared API
using the power of interior mutability.

This crate is `#![no_std]` by default. The `std` feature can be enabled to access functionality that requires the full
standard library.