[maven-release-plugin] prepare for next development iteration
Change the behavior of equals() and hashcode() for Jeppetto-managed objects

Previously, Jeppetto implemented classes' equals() and hashcode() methods.  It attempted to
determine equality based on the overall contents of an object rather than the approach the app
developer would take.  Although strictly correct, it could create a significant overhead for
equality checks, and might occasionally create false negatives (e.g. it might be too strict).

This change moves responsibility for these methods to where it belongs, the delegate
and/or super classes.  However, with this change there is one gotcha which is that the
same "object" but at different versions may be considered equal.  It will be up to the app
developer to manage this scenario  by either checking the __olv value or other fields
that will disambiguate the version such as a lastUpdatedTime).

Test cases added to validate behavior.
Update test support to latest mongo driver.
Support for MongoDB "view" objects.

This change lets a single MongoDB collection be used as the backing data for multiple object types
in the application.  Each DAO instance will continue to manage objects of a specific type, but if a
DAO is responsible for an object that is a view of another object, it can be configured with the
name of the class it is a "viewOf" and the "collection" where the data is found.  Jeppetto will
automatically determine what fields it should retrieve and populate the correct object.

Notes:
- Field names between the main object and view objects need to match (so Jeppetto knows what
   data to put where).
- Nested objects can be of different types (though names must match).  Jeppetto will only pull
   the requested fields for the nested objects.
- It is not required to include the "id" field in the view object.  This supports very fast data
   retrieval using MongoDB's covered index feature if the id is not part of the index.  Be
   aware that both the optimistic lock field and the access control field will be fetched if
   those features are enabled.
- View objects can be used for updates, though it requires the "id" field to be present.

Test cases added to validate behavior.
Reduce test log verbosity.
Reference-based writes: API and MongoDB implementation.

The scenario for this is that a common update needs to be made to one (or several) objects.
Previously, this would require a query to load the objects, each object would be modified, and
then each would be saved one at a time, resulting in 1+N or even N+N db calls.  With
referenced-based writes, this is now reduced to just 1 db call.  There are, of course, a couple
of caveats:

- Reference-based writes happen without reading the underlying object so it is possible
  that another thread could update the same objects.  Optimistic lock support is not yet
  available.
- Although most things can be updated using this mechanism, not every possible change
  is supported.  In particular, embedded collections cannot have items both add()ed and
  remove()d in the same update (though clear()ing and then add()ing is supported).

Besides being able to leverage the basic reference methods in GenericDAO, there is
support for DSL-style and annotation-based methods.  The DSL prefix is "referenceBy"
and works similarly to "deleteBy" methods.

Other changes include:

- Functional tests for references has been added.
- The GenericDAO now has findByIds(ID... ids) and deleteByIds(ID... ids) methods.
- The VelocityEnhancer class now takes additional context helpers that can be
  leveraged during enhancement.
Update to the latest MongoDB java driver and mark it 'provided'.

Declaring the MongoDB driver as 'provided' means Jeppetto users now need to specify which version
they want in their application, but makes it easier to select a specific version that is not the same
as what is declared w/in Jeppetto.
Add 'oldPlan' to list of paths to ignore when explain is called.
[maven-release-plugin] prepare release jeppetto-0.8
Merge branch 'release/0.8' (early part)