Deflate

* Library updates:

* Improved compression performance slightly.

* Detect arm64 CPU features on Apple platforms, which should improve
performance in some areas such as CRC-32 computation.

* Program updates:

* The included `gzip` and `gunzip` programs now support the `-q` option.

* The included `gunzip` program now passes through non-gzip data when both
the `-f` and `-c` options are used.

* Build updates:

* Avoided a build error on arm32 with certain gcc versions, by disabling
building `crc32_arm()` as dynamically-dispatched code when needed.

* Support building with the LLVM toolchain on Windows.

* Disabled the use of the "stdcall" ABI in static library builds on Windows.

* Use the correct `install_name` in macOS builds.

* Support Haiku builds.

* Added an additional check to the decompressor to make it quickly detect
certain bad inputs and not try to generate an unbounded amount of output.

Note: this was only a problem when decompressing with an unknown output size,
which isn't the recommended use case of libdeflate. However,
`libdeflate-gunzip` has to do this, and it would run out of memory as it would
keep trying to allocate a larger output buffer.

* Fixed a build error on Solaris.

* Cleaned up a few things in the compression code.

* Made many improvements to the compression algorithms, and rebalanced the
compression levels:

* Heuristics were implemented which significantly improve the compression
ratio on data where short matches aren't useful, such as DNA sequencing
data. This applies to all compression levels, but primarily to levels 1-9.

* Level 1 was made much faster, though it often compresses slightly worse than
before (but still better than zlib).

* Levels 8-9 were also made faster, though they often compress slightly worse
than before (but still better than zlib). On some data, levels 8-9 are much
faster and compress much better than before; this change addressed an issue
where levels 8-9 did poorly on certain files. The algorithm used by levels
8-9 is now more similar to that of levels 6-7 than to that of levels 10-12.

* Levels 2-3, 7, and 10-12 were strengthened slightly.

* Levels 4-6 were also strengthened slightly, but some of this improvement was
traded off to speed them up slightly as well.

* Levels 1-9 had their per-compressor memory usage greatly reduced.

As always, compression ratios will vary depending on the input data, and
compression speeds will vary depending on the input data and target platform.

* `make install` will now install a pkg-config file for libdeflate.

* The Makefile now supports the `DISABLE_SHARED` parameter to disable building
the shared library.

* Improved the Android build support in the Makefile.

* Added `-t` (test) option to `libdeflate-gunzip`.

* Unaligned access optimizations are now enabled on WebAssembly builds.

* Fixed a build error when building with the Intel C Compiler (ICC).

* Fixed a build error when building with uClibc.

* libdeflate's CI system has switched from Travis CI to GitHub Actions.

* Made some improvements to test scripts.

* Added support for compression level 0, "no compression".

* Added an ARM CRC32 instruction accelerated implementation of CRC32.

* Added support for linking the programs to the shared library version of
libdeflate rather than to the static library version.

* Made the compression level affect the minimum input size at which compression
is attempted.

* Fixed undefined behavior in x86 Adler32 implementation. (No miscompilations
were observed in practice.)

* Fixed undefined behavior in x86 CPU feature code. (No miscompilations were
observed in practice.)

* Fixed installing shared lib symlink on macOS.

* Documented third-party bindings.

* Made a lot of improvements to the testing scripts and the CI configuration
file.

* Lots of other small improvements and cleanups.

* Prevented gcc 10 from miscompiling libdeflate (workaround for
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94994).

* Removed workaround for gcc 5 and earlier producing slow code on ARM32. If
this affects you, please upgrade your compiler.

* New API function: `libdeflate_zlib_decompress_ex()`. It provides the actual
size of the stream that was decompressed, like the gzip and DEFLATE
equivalents.

* `libdeflate_zlib_decompress()` now accepts trailing bytes after the end of the
stream, like the gzip and DEFLATE equivalents.

* Added support for custom memory allocators. (New API function:
`libdeflate_set_memory_allocator()`)

* Added support for building the library in freestanding mode.

* Building libdeflate no longer requires `CPPFLAGS=-Icommon`.