update README and make sure examples there work
add EXPRESSION-CASE; simplify expression processing

* EXPRESSION-CASE is a bit like CL:TYPECASE but clauses correspond to
  Esrap expression constructors. EXPRESSION-CASE ensures that all
  expression constructors are handled (unless there is a
  catch-all-clause) and that processed expressions are valid.

* INVALID-EXPRESSION-ERROR is a new error condition which is signaled
  when an invalid expression is encountered.

* CHARACTER-RANGE is a new type which simplifies validation of
  CHARACTER-RANGES expressions.

* *EXPRESSION-KINDS* is a new global variable which stores all
   available expression constructors and the corresponding types. Has
   to be available at compile-time via EVAL-WHEN :COMPILE-TOPLEVEL,
   :LOAD-TOPLEVEL and :EXECUTE.

* Rename VALIDATE-EXPRESSION -> CHECK-EXPRESSION since it acts like
  CL:CHECK-TYPE. Unused function VALIDATE-CHARACTER-RANGE has been
  removed.

* In addition, use EXPRESSION-CASE in %EXPRESSION-DEPENDENCIES,
  %EXPRESSION-DIRECT-DEPENDENCIES, EVAL-EXPRESSION and
  COMPILE-EXPRESSION

* New tests: DEFRULE.CHECK-EXPRESSION, PARSE.STRING and
  PARSE.CASE-INSENSITIVE
fix a few typos in the manual
support left recursive rules with potential performance hit

As described in

  Alessandro Warth, James R. Douglass, Todd Millstein, 2008,
  "Packrat Parsers Can Support Left Recursion".
  http://www.vpri.org/pdf/tr2007002_packrat.pdf

* WITH-CACHED-RESULT detects left recursion and (unless signaling an
  error has been requested) handles the situation by growing a "seed
  parse" via repeated application of the rules involved in the left
  recursion.

* The new special variable *ERROR-ON-LEFT-RECURSION* switches between
  this new behavior and the old behavior of signaling a LEFT-RECURSION
  error.

* The system version has been bumped from 0.9 to 0.10 and a feature
  :ESRAP.CAN-HANDLE-LEFT-RECURSION is pushed onto *FEATURES* when the
  system is loaded.

* Basic unit tests for direct and indirect left recursion have been
  added:

  * LEFT-RECURSION.[IN]DIRECT.{SUCCESS, CONDITION}
  * The examples in file example-left-recursion.lisp are tested in
    EXAMPLE-LEFT-RECURSION.{LEFT-ASSOCIATIVE, RIGHT-ASSOCIATIVE,
  * WARTH}

* The manual and README have been extended.

* The new file example-left-recursion.lisp contains multiple grammars
  which exercise and illustrate the new capability.
implement and document rules for repeated/combined DEFRULE options

* The :when DEFRULE option cannot be repeated (This had already been
  implemented, but the documentation string did not explicitly state
  the fact)

* All DEFRULE options which specify transformations can now be
  repeated and/or combined. The resulting transformation is the
  composition of the supplied transformations in the specified
  order. Only the first transformation can receive bounds via &BOUNDS.

* The system version has been bumped from 0.10 to 0.11 and a feature
  :ESRAP.MULTIPLE-TRANSFORMS is pushed onto *FEATURES* when the system
  is loaded.

* Unit tests have been added: MULTIPLE-TRANSFORMS.{1,INVALID}
update authorship, copyright, email addresses
handle inactive rules correctly in PROCESS-PARSE-RESULT

* PROCESS-PARSE-RESULT could signal a TYPE-ERROR for INACTIVE-RULE
  results

* Test case for toplevel and non-toplevel inactive rules have been
  added in test CONDITION.1
First attempt at providing an additional terminal READ.