Subgrammars: prototype design for #25 (re-usable parsers)

[ivanbakel]

Essentially a very crude and unassuming design for how you might choose to implement #25.

The essential stuff:

• grammars can share rules, which marks them pub(crate) but doesn't produce the wrapper api. Since templates are inlined, they can't be shared.
• grammars can import other grammars, which opens up their shared rules to be used under that grammar name with the syntax <grammar_name>::<rule_name>.
• grammars can import with a converter, which is a piece of Rust code which is the arguments to the second grammar written in terms of the arguments of the first (if any)
• Rules are actually accessed by assuming that the imported grammar's code lives in a module of the same name under the parent module - if either of these things are not true, you get a cryptic compile error
• subgrammar types are converted to/from at need, but are not yet persisted by the parent grammar i.e. a new ParseState is created at each boundary, etc.

This isn't meant to be the final design - cache persistence of subgrammars would be good, for example, and a better build-time system of catching errors (such as by sharing a Compiler, maybe?) - but I would appreciate any feedback about how this aligns with what you imagined and what could/should be improved.