For many docs/guides projects, it would be useful to divide Scheme
implementations into tiers. The big, full-featured ones are complex and
benefit from a detailed exposition of their features and pitfalls.

Meanwhile, it's still nice to cover small implementations, but since
they are simpler they require less detail. It'll also a bit confusing
(especially to newbies) to have large and small implementations mixed up
in the same listing.

Hence some kind of tier system would be useful. Since the "best" choice
of implementation can be completely opposite based on the requirements
of each project (e.g. microcontroller vs busy server) we can't use that
as a metric. But size / number of features can be a reasonable
approximation.

Here's a sketch: what if a "full-featured" implementation is one that has:

* Full continuations and numeric tower
* Threads (OS threads and/or green threads)
* Host-language FFI (C/C#/Java/etc.)
* Debugger
* Profiler
* Scheme-level compiler optimizations
* Compilation to native code (either its own compiler, or via C/JVM/CLR)
* Interpreter (or incremental compiler in the REPL)

Would these be reasonable criteria?

At the other extreme, there would be things like Mini-Scheme, S9 and the
microcontroller Schemes.

There should probably be 1-2 categories in between. Chibi is
significantly bigger than something like FemtoLisp, and `cloc` says that
Gauche is more than 10x the size of Chibi.