Deflate

Significantly improved decompression performance on all platforms. Examples
include (measuring DEFLATE only):

| Platform | Speedup over v1.13 |
|------------------------------------|--------------------|
| x86_64 (Intel Comet Lake), gcc | 1.287x |
| x86_64 (Intel Comet Lake), clang | 1.437x |
| x86_64 (Intel Ice Lake), gcc | 1.332x |
| x86_64 (Intel Ice Lake), clang | 1.296x |
| x86_64 (Intel Sandy Bridge), gcc | 1.162x |
| x86_64 (Intel Sandy Bridge), clang | 1.092x |
| x86_64 (AMD Zen 2), gcc | 1.263x |
| x86_64 (AMD Zen 2), clang | 1.259x |
| i386 (Intel Comet Lake), gcc | 1.570x |
| i386 (Intel Comet Lake), clang | 1.344x |
| arm64 (Apple M1), clang | 1.306x |
| arm64 (Cortex-A76), clang | 1.355x |
| arm64 (Cortex-A55), clang | 1.190x |
| arm32 (Cortex-A76), clang | 1.665x |
| arm32 (Cortex-A55), clang | 1.283x |

Thanks to Dougall Johnson (https://dougallj.wordpress.com/) for ideas for many
of the improvements.

* Changed the 32-bit Windows build of the library to use the default calling
convention (cdecl) instead of stdcall, reverting a change from libdeflate 1.4.

* Fixed a couple macOS compatibility issues with the gzip program.

This release focuses on improving the performance of the CRC-32 and Adler-32
checksum algorithms on x86 and ARM (both 32-bit and 64-bit).

* Build updates:

* Fixed building libdeflate on Apple platforms.

* For Visual Studio builds, Visual Studio 2015 or later is now required.

* CRC-32 algorithm updates:

* Improved CRC-32 performance on short inputs on x86 and ARM.

* Improved CRC-32 performance on Apple Silicon Macs by using a 12-way pmull
implementation. Performance on large inputs on M1 is now about 67 GB/s,
compared to 8 GB/s before, or 31 GB/s with the Apple-provided zlib.

* Improved CRC-32 performance on some other ARM CPUs by reworking the code so
that multiple crc32 instructions can be issued in parallel.

* Improved CRC-32 performance on some x86 CPUs by increasing the stride length
of the pclmul implementation.

* Adler-32 algorithm updates:

* Improved Adler-32 performance on some x86 CPUs by optimizing the AVX-2
implementation. E.g., performance on Zen 1 improved from 19 to 30 GB/s, and
on Ice Lake from 35 to 41 GB/s (if the AVX-512 implementation is excluded).

* Removed the AVX-512 implementation of Adler-32 to avoid CPU frequency
downclocking, and because the AVX-2 implementation was made faster.

* Improved Adler-32 performance on some ARM CPUs by optimizing the NEON
implementation. E.g., Apple M1 improved from about 36 to 52 GB/s.

* 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.