Basic implementation of AsyncParser is done.

Seems to pass some simple examples in the REPL. Needs actual unit
tests as well as benchmarking.
Add tests of AsyncParser chunking, and fix some bugs they found.
Improved access controls for AsyncParser.
Refactored async parsing to provide cleaner interface.

Per John's suggestions, JsonParser now has a parseAsync method.
Given a ParseAsyncState instance and an Option[ByteBuffer], it
will return (ParseAsyncState, Seq[Validation[Throwable, JValue]]).
The state instances are internally mutable but provide no public
methods besides copy(), or any constructors which could close over
global state.

Benchmarking suggests that for 36.7M of input data the new method is
about as efficient as the old one for chunk sizes of 10K and
greater. For chunk sizes of 1K, the new method runs in 150% of the
time, and for chunk sizes of 100 bytes, it runs in about 250% of
the time.

It might be nice to maintain some form of the old interface, since
for large streams and/or small chunk sizes, the new method does have
a lot more overhead. In many cases though it will be fine.
Add type-specific overloads for merge on JObject and JArray
Fix RealMongo to use new merge on options
Create AsyncResult abstract datatype for parseAsync.

AsyncResult is a sealed trait with three members:

  * AsyncOk: for successful parsing, wraps an AsyncState
  * ParseError: parsing failed, wraps a ParseException
  * OtherError: some other failure, wraps a Throwable

This commit also removes the heuristic for error recovery. As per
discussions with Kris, if an error is encountered, the previously
parsed rows are returned along with an error result.
Fix specs now that mock mongo is gone, add new harness to run a real mongo instance for specs
Add startup pause (mongo Java driver hangs nondeterministically without it)
Refactor AsyncParser and restructure Parser hierarchy.

This commit does a number of things:

  1. Splits the JParser.scala file out into a number of smaller
     files, to make the code a bit more accessible.

  2. Introduce AsyncParse, a type representing the result of an
     asynchronous parse, which contains a Seq[ParseException] and
     a Seq[JValue].

  3. Begin tracking line and column information correctly in Parser,
	 and report this information in ParseException.

  4. Use newlines for error-recovery, according to our previous
     discovery. If the error occurs at a line boundary, the parsing
     will be restarted from that line. Otherwise, the parser will
     scan forward to the next newline and then resume.

  5. JParser.parseAsync has been changed to accept an AsyncParser
     and return (AsyncParse, AsyncParser).

The commit also adds a basic test of the error recovery mechanism,
which ensures that the line/column information for parse errors is
correct.
fixed visibility issues identified by jdegoes
Fix JValue -->? to use isAssignableFrom instead of Class ==
Make JNum sublcass hashCodes AWESOME
Make JNum hashCode even *more* awesome

As Erik pointed out, "...SI-6173 is what causes this problem, 6173 is prime, *and* if you remove any single digit, it's still prime!"
Merge pull request #63 from non/topic/parser-io

Topic/parser io
Merge pull request #64 from dchenbecker/topic/fix-up-mongo-removal

Topic/fix up mongo removal
improved compare/ordering performance
resolved conflicts