Blazinterner: efficient and concurrent interning of generic data

Here are the main features offered by this crate.

• Generic: You can intern any data type that implements Hash and Eq, not just strings. The interned type doesn't even have to be Sized (for example str), as long as you provide a Sized storage type (such as Box<str>) that can be borrowed as the interned type.
• Efficient: Each Interned value contains only a 32-bit index. The corresponding Arena stores each value directly in an AppendVec, plus the 32-bit index in a raw hash table (DashTable). To intern a value of type T using storage type S, you can pass any type that implements Borrow<T> and Into<S>, which allows avoiding unnecessary copies. For example, in an Arena<str, Box<str>> you can intern many string types: &str, String, Box<str>, Cow<'_, str>, etc.
• Concurrent: The Arena is Sync, and allows simultaneous reads and writes. More specifically, retrieving values via Interned::lookup() and Interned::lookup_ref() is always wait-free, even when a write happens concurrently! This is thanks to the underlying AppendVec implementation. However, only one write (using Interned::from()) can happen at a time on a given arena, due to an exclusive write lock.

no_std support

The base functionality of Blazinterner is no_std, but requires the alloc crate. Exceptions are:

• The sync feature, which enables concurrent usage of an arena, which under the hood requires the standard library to use synchronization primitives such as mutexes.
• The std feature, which provides additional APIs such as print_summary() that writes debug information to the standard output.