Refactor RuleVisitor._resolve_refs

When resolving circular references it is necessary to avoid infinite
recursion.  Previously this was done by tracking unwalked_names and
walking_names.  Now infinite recursion is prevented by setting
expr.members to None while recursively resolving member expressions.
Improve exception message when you forget to declare a visitor method.
Make clear that the grammar is a string, not some magical pile of operator overloading.

Marcell got the wrong impression.
Show the production visit_or_term unpacks.

Marcell suggested this while learning the lib.
Correct visit_or_term example.
Improve NodeVisitor documentation.

Still not complete, but it's better.
Add `parse()` and `match()` convenience methods to `NodeVisitor`, and add the concept of a default grammar for a visitor.

This makes the common case of parsing a string and applying exactly one visitor to the AST shorter and simpler.

It is unlikely that a visitor would ever be used with more than one grammar, so I expect all visitors to have an easily chosen default grammar.
Implement grammar-from-docstrings visitors. Close #46. Consolidate public API in __init__.

There's no nice way to start parsing from a non-default rule using the NodeVisitor.parse() shortcut, but if you need to do that, I suppose it's time to pay for what you eat.
Improve some Grammar docs.
Tersen just a little bit. Make members consistently a tuple, not sometimes None.
Drastically simplify _resolve_refs(). Close #34.
Stop relying on the object identity of multiple instantiations of ().

I don't think that's guaranteed across Python implementations.
Make Grammars extensible through custom Python code using "custom rules". Close #47.

* Add `expression()` factory for turning simple lambdas into Expressions, mostly for use internally by Grammars in converting custom rules.
* Add support for "custom rules" in Grammars. These provide a hook for simple custom parsing hooks spelled as Python lambdas. If you want to abuse the packrat cache, you can even be stateful! (If this becomes useful, we'll add another arg for passing a proper blackboard around.) For heavy-duty needs, you can put in Compound Expressions with LazyReferences as subexpressions, and the Grammar will hook them up for optimal efficiency--no trips through the Grammar's hash at parse time.
* Allow grammars without a default rule (in cases where there are no string rules), which leads to also allowing empty grammars. Maybe someone generating grammars dynamically will find that useful.
Replace GrammarFromDocstrings with @rule. Everything works fine except subclassing; I haven't figured that out yet.

@rule is better. It's more explicit, it's the same number of lines, it avoids visitors having to subclass something else, and it lets us still have visitor docstrings that actually document things.
Bring readme up to date.
Move custom rules to a `custom` kwarg.

Custom rules are enough of a niche thing that it's not worth making future kwargs so hard to add.
Make _match() public. Close #52.

It should be this way not only so it can be called from custom rules but also to make the calls to other Expressions' _match methods from Compound expressions legit.
Make Compound public, in case anyone wants to make custom Expressions based on it.

To do: make all Expressions worth subclassing public.
Replace default_rule kwarg with .default(). Refs #30.
Make UndefinedLabel no longer a kind of VisitationError.

This way, we can reuse it for when people try to parse using AbstractGrammars.

It being a VisitationError never made any sense anyway. It didn't even call the VisitationError constructor or comply with its invariants.