1. Instead of storing an offset to the previous matching byte in the
   index, store the next matching byte bigram. Since the compression
   doesn't break even unless at least 3 bytes match, any single-byte
   matches in the index should just be skipped.

   Since this eliminates these false positives in one pass, it also
   removes work that would otherwise be done during every walk of the
   index's offset chain - possibly several times. This greatly
   reduces the time spent in find_longest_match().

   EDIT: This prematurely discards information from the index,
   damaging the overall compression effectiveness. Some of the
   links being skipped are still necessary for other chains, so
   they cannot be eliminated this way. It's still possible dynamic
   programming can be used for this, but the strategy in this
   commit doesn't quite work.

2. Eliminate the test of the first byte, since indexing already
   incorporates this comparison ahead of time.

*comment on rebase*

Since heatshrink.c is just the command-line interface,
but heatshrink.h is constants common to the encoder and decoder,
rename it to heatshrink_common.h to avoid confusion.

The "Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution."
clause of the BSD license seems to be problematic manufacturers that
do not otherwise provide written documentation for hardware.

There seems to be diminishing returns after 32 bytes, and it takes
significantly less space. (It's only a default, anyway.)

This eliminates the possibility of infinite loops caused by counters
overflowing and preventing the output buffer full or input exhausted
conditions from being reached.

Previously, suspending between the two bytes of a >8-bit index or count
could lead to accumulation of an incorrect value. This commit breaks
each of the index and count states into X_{msb,lsb}, where _msb reads
the >8th bits and stores them in the accumulator, and _lsb reads the
lower 8 bits (or all of them, if the total value is < 8). This adds
another point where the state machine can suspend and resume without any
loss of information, if necessary.

Since they're only stored as `uint16_t`s, disallow overly large sizes.

Added summary of key features and some formatting

I thought it might be handy to have a list of key features on the 
github page so that if someone runs into it looking for a compression
library they can know right away if it's what they're looking for.