Make regalloc2 #![no_std] (#119)

* Make regalloc2 `#![no_std]`

This crate doesn't require any features from the standard library, so it
can be made `no_std` to allow it to be used in environments that can't
use the Rust standard library.

This PR mainly performs the following mechanical changes:
- `std::collections` is replaced with `alloc::collections`.
- `std::*` is replaced with `core::*`.
- `Vec`, `vec!`, `format!` and `ToString` are imported when needed since
  they are no longer in the prelude.
- `HashSet` and `HashMap` are taken from the `hashbrown` crate, which is
  the same implementation that the standard library uses.
- `FxHashSet` and `FxHashMap` are typedefs in `lib.rs` that are based on
  the `hashbrown` types.

The only functional change is that `RegAllocError` no longer implements
the `Error` trait since that is not available in `core`.

Dependencies were adjusted to not require `std` and this is tested in CI
by building against the `thumbv6m-none-eabi` target that doesn't have
`std`.

* Add the Error trait impl back under a "std" feature

src/indexset.rs

@@ -5,8 +5,10 @@
 
 //! Index sets: sets of integers that represent indices into a space.
 
-use fxhash::FxHashMap;
-use std::cell::Cell;
+use alloc::vec::Vec;
+use core::cell::Cell;
+
+use crate::FxHashMap;
 
 const SMALL_ELEMS: usize = 12;
 
@@ -151,10 +153,10 @@ impl AdaptiveMap {
 
 enum AdaptiveMapIter<'a> {
     Small(&'a [u32], &'a [u64]),
-    Large(std::collections::hash_map::Iter<'a, u32, u64>),
+    Large(hashbrown::hash_map::Iter<'a, u32, u64>),
 }
 
-impl<'a> std::iter::Iterator for AdaptiveMapIter<'a> {
+impl<'a> core::iter::Iterator for AdaptiveMapIter<'a> {
     type Item = (u32, u64);
 
     #[inline]
@@ -292,7 +294,7 @@ impl Iterator for SetBitsIter {
         // Build an `Option<NonZeroU64>` so that on the nonzero path,
         // the compiler can optimize the trailing-zeroes operator
         // using that knowledge.
-        std::num::NonZeroU64::new(self.0).map(|nz| {
+        core::num::NonZeroU64::new(self.0).map(|nz| {
             let bitidx = nz.trailing_zeros();
             self.0 &= self.0 - 1; // clear highest set bit
             bitidx as usize
@@ -300,8 +302,8 @@ impl Iterator for SetBitsIter {
     }
 }
 
-impl std::fmt::Debug for IndexSet {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for IndexSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         let vals = self.iter().collect::<Vec<_>>();
         write!(f, "{:?}", vals)
     }