Add parentheticals to our language [parsimonious]

Note that the left side of the `operation` rule can now self-recurse:
operation->element->parenthetical->expression->operation. However, a
parenthetical must have...a parenthesis, so we're still anchored and
don't endlessly recurse.

Look at how everything that referred directly to the `number` rule now
refers to `element`. This sort of composition is important in keeping a
grammar clean. We could do away with the `element` rule:
    expression    = operation / parenthetical / number
    operation     = (parenthetical / number) operator expression
But now we have repetition. Just like in any other programming task,
when you see repetition in your grammar you should extract it into a
single place to which you can make reference.

(also, we'd have to change generic_visit if we didn't have a named rule
for elements.)
Allow arbitrary whitespace between tokens [parsimonious]

Normally I wouldn't use such a short variable name as "ws", but I have
my reasons:
    a) whitespace is a common, simple thing that doesn't impose much
        cognitive overhead.
    b) sprinkling the word "whitespace" throughout the other rules makes
        them unpleasantly long.

Note that although the tests don't call it out, this resolves a minor
ambiguity in the language: previously you could have funky-looking
expressions like "5+-2". The parser knew what this meant--"add five to
negative two"--but it looked weird. Now that you can put spaces it's
much clearer what's meant by "5 + -2".
Add a `d` operator that rolls n dice of size x [parsimonious]

This doesn't illustrate a lot about parsers, but die-rollers are fun,
and of course it shows that functions in your defined language needn't
have a 1-1 mapping to functions in your host language.