Added debugging inspection and instrumentation and fixed some bugs.

Details:

- Instead of using #\nul as a distinguished null character, use
  unicode left-tack (just like the paper) to make `write` output more
  succinct.  (This choice of selection has been abstracted into the
  `nul-char` definition at the top.)

- Temporarily turned on the `writln` instrumentation in
  `earley-predictor`, `earley-completor`, and `earley-scanner`.
  Added printouts for when they each add an addition to the
  state sets as well.

- Bug fix: `earley-completor` needs to check that the next
  symbol after the cursor in the production is actually the
  symbol for sequence we are completed; i.e., C_q,{l+1} == D_p
  (Doing this removed a lot of bogus state sets from the result;
   however as implemented, it seems to have removed too much.)

- Added `earley-compute` procedure which returns the earley
  computation state immediately prior to the `'accept` or `'reject`
  result.

- Added `summarize-stateset` which combines entries that differ solely
  in their lookahead; this is the presentation that e.g. Figure 1 from
  Earley '70 uses.
Use `state-set-add/!' routine instead of the `workset-add/!` routine.

(The former is arguably "more abstract", though they are equivalent
for the moment.)
Fixed `lookahead-matches?` bug.

Added origin-tracking information to states so I can tell why they
were added.  The field is generalizable to arbitrary S-exp's, and
really the intention is that I could plug-in the tree to justify it;
such back-pointers might also be useful for building up *a* parse-tree
(but it might not be as helpful for building *all* parse trees).

Added instrumentation tracking points when states are added to the
sets, as well as when completor considers doing such additions.
Fixed more bugs.

- Attempted to switch to consistently treating `i` as 1-index into string
  (and then adjusting accordingly when actually referencing or comparing
  against string length)

- Added abstract state-set record, which carries a list of nulled
  nonterminals (those that have been found to rewrite to the empty
  string in the grammar at this state), and then eagerly add more
  states shifting over the null nonterminal when necessary.
  (This is point (5) in the Implmentation discussion of Early '70)

- Fixed serious bug in `find-prefixes`, which was assuming that
  the grammar or expansion map would always have a non-empty list
  as first entry; this is not true when the prefix list is itself
  an empty list.

- Also added some code to guard against empty `gamma` argument in
  `find-prefixes`, though I am not 100% sure this was actually
  necessary.

- Revised control-flow of earley-step, though I am not sure that
  this was actually necessary.  (Still, this version seems more
  robust.)

- Abstracted out `report-visit` and `report-progress` for
  instrumentation of predictor, completor, and scanner.

- Guard against premature shift in completor.

- Added `earley-iterate` routine, which is useful for getting to
  particular points in a computation history.
Fixed serious bug in find-prefixes, and added more examples from Earley '70.

All changes:

 * I started transcribing "interesting" Unicode characters that I
   found when I started looking over the list of [logical
   symbols](http://en.wikipedia.org/wiki/List_of_logic_symbols) on
   Wikipedia.  They are in a separate file, `named-chars.sch`, that I
   will commit separately.  I've added Larceny-specific code to this
   file that attempts to load named-chars at load time if that file
   exists in the same directory as this file.

* `find-prefixes` was only substituting the full sentences for a
  symbol it encountered on gamma; but it should also use the prefixes
  it finds that would fill up the remaining capacity for the length of
  the prefix we are attempting to generate.  (I've gone through a
  couple different iterations now on how to implement this simple
  function; I should probably buckle down and do it properly now,
  since at least two of my "obvious" attempts have actually had bugs.

* Introduced a new `report-progress-if-changed` instrumentation
  abstraction so that I can choose whether I want to see all
  attempted changes (e.g. additions to state sets), or if I
  only want to see attempts that actually effect change.

* Added UBDA, BK, PAL, G-{1,2,3,4}, and propositional calculus
  examples from Earley '70.
  (I have not yet gone through all of the tests he provides for the
   propositional calculus, though.)
Fix unbound global variable references.

A couple of characters that are referenced in the definition of propositional-calculus
that I needed to copy over from `named-chars.sch`.
A hodgepodge of interesting unicode characters.
Added the last two example grammars, GRE and NSE, from Earley '70.
Ignore Larceny generated .fasl files.
Refine debug output: omit todo/done members from printout when empty.
Slight deviation from earley: process all last char states before accept.
Decided to follow the example of Aycock and Horspool '01 and use a
large black circle to mark the cursor position.

(Another potentially nice option would be a cursor in the style of a
sideways H... maybe I will look for that too.)
checkpoint