Started working on partitioning. Added toplevel clause processing.
Added structure verification of standalone terminal descriptions.
Started implementing partitioning of extension terminals.
Implemented proper handling of terminal modification extensions.
Refactored layout of code. Made standalone check more strict.
Implemented standalone nonterminal and production filtering.
Implemented extension nonterminal and production filtering.
Added 'success' tests for toplevel partitioning.
Added 'failure' tests for structural errors in toplevel clauses.
Added 'success' tests for standalone terminal filtering.
Adde 'failure' tests for standalone terminal filtering.
Added 'success' tests for extension terminal partitioning.
Started writing 'failure' tests for extension terminals.

Finally I have realized that the current approach to partitioning and
checking syntax is deficient. It is not right to first roughly split
clauses into classes by guessing their true class, and then verify our
guess.

Backtracking will be hard to implement with syntax-rules, and we
should backtrack if our guess was wrong but the clause may be still
syntactically correct. A better approach will be to first filter our
entirely correct clauses, then check for remaining ones, guess their
classes, and then produce some meaningful error message.

Dunno about multiple errors. `syntax-error` does not give a chance
to do it, so I guess it will be just the first erroneous clause to be
reported.
'Failure' tests maintenance.

* Added more tests for extension terminals (removals and modifications).
* Renamed tests for the names to be shorter.
* Reformulated some error messages for precision and consistency.
Added Travis CI intergration.

`run-all-tests' script is a bit hairy, but it does the job.
Some day I will make it better. I hope.

CI is currently enabled only for 'partitioning' branches.
It will be enabled for all branches when this gets merged into master.
Merge branch 'partitioning-tests' into 'partitioning'
Reimplemented standalone terminal partitioning in a new way.

(All standalone tests actually pass.)

Now structure verification functions come in three flavors:

  $can-be:<x>? - a proper predicate (returns either #t or #f),
    provides a non-strict match with <x>: passing can-be test
    is necessary, but not sufficient for the thing to be <x>

  $is-an:<x>?  - a proper predicate too, but this time it is
    a strict match with <x>: passing 'is-a' test is a necessary
    and sufficient requirement for the thing to be <x>

  $must-be:<x> - an assertion that the thing is actually <x>:
    failure to satisfy such assertion is a syntax error;
    a passing assertion returns an undefined value

They all are implemented in terms of $verify:<x> functions. These
will be documented later, when all terminals are rewritted in this
way. Because I still do not entirely like how the functions are named.
Reimplementated extension terminal partitioning in a new way.

All failure tests actually pass. Success tests do not, because
valid extension terminals are not properly postprocessed yet.
This will be done together with some refactoring of the code.

Also, tests tweaks because I have found more peculiar clauses.

Also x2, tests are incredibly slooooow now. Need to do something
about it in the future. I do not want the define-language to be
as slow as these tests are.
Refactored and cleaned up terminal partitioning code

Now all tests pass.

Ditched out a fair bit of unused functions in meta-var processing.

Also updated docs (ha-ha).
Merged branch 'partitioning' into 'partitioning-tests'

Pulling updates to partitioning implementation to continue
writing nonterminal tests.