Support the Log API

Support the [Log API](http://docs.datomic.com/log.html)
API CHANGE: DDatabase.entity returns empty DEntity rather than throw exception

this undoes an old design decision to throw an exception when an entity lookup returns an entity with no keys.
Merge branch 'topic/rw-kw-implicits' into maintenance
bump version for next maintenance release
Merge pull request #78 from searler/develop

add unapply for DDatom
Merge pull request #72 from pellucidanalytics/topic/entity-semantics

make entity method consistent with Datomic semantics
fix: the schema manager always recurses

this fix ensure that the schema manager always follows the dependencies, even if parent schema fragment is already present.
Merge branch 'fix/recursive-schema-manager' into develop

Pull in fix to schema manager.
annotate type classes for better error messages

- make use of the implicitNotFound annotation to give better compiler errors when there is no available instance of a type class
finalize case classes and seal traits where applicable

this leads to better compiler optimization and error reporting
make Connection, PartialAddEntity, TxReport, and TxReportQueue a classes

 - should be a classes, not a traits
 - optimize construction and invocation
minor: better implicitNotFound error messages

- improve the language of the error messages: try to avoid mentioning ‘injectivity’, and make suggestions to the user to help correct any errors
- ditch DatomicBij
fix: correct definition of transaction data for new partitions
Merge pull request #75 from pellucidanalytics/topic/log-api

Support the Log API
Merge pull request #80 from pellucidanalytics/topic/implicitNotFound

Annotate type classes for better error messages
Merge pull request #81 from pellucidanalytics/topic/oop

Finalize case classes, seal traits, and turn traits into classes
Merge pull request #82 from pellucidanalytics/fix/add-partition

Correct definition of transaction data for new partitions
major: completely replace macro and parser system!

 - strip out custom parser and just delegate to Datomic/Clojure’s EDN reader
 - new macros for keywords, queries, and rules
 - delete all data types associated with the parser AST and terms
 - remove EntityOps and Ops macros… not going to support these
 - new query object that encapsulates a Clojure datastructure
 - new names for typed query objects

new query macro works as follows:
1. take a string literal and run it through datomic.Util.read
2. if the query is in map form, fine, otherwise transform it from vector form to map form (with minimal validation)
3. compute the input and output arity
4. convert the clojure datastructure into literal code
5. wrap it in a typed query object that encodes the input and output arity

the macros for keywords and rules, do mimimal further validation

note: use of Clojure functions in a macro require some classloader hacks to deal with Clojure weirdness

closes #12 : complier position information is not going to be available in general with the EDN reader
closes #43 : no longer relevant
resolves #45 and resolves #46 : supports any and all EDN / Clojure
implement string interpolation / code splicing into query

As well as string literals as the input to the query macro, allow
support for s"abc $d efg" style string interpolation. The macro will
evaluate the string constant parts at compile time, using the symbol
"!" as a placeholder for the code parts, and then splice the code trees to
parse the code parts of the string interpolation at runtime.

s"[:find ?e :where [?e $attr]]"

becomes equivalent to

{:find [?e]
 :where [[?e datomic.Util.read(attr.toString)]]}

So this becomes a multi-phase macro. The string interpolation is a
macro and takes

s"[:find ?e :where [?e $attr]]"

to

StringContext.apply("[:find ?e :where [?e ", "]]").s(attr)

then the string constants are turned into

"[:find ?e :where [?e ! ]]"

and turned into literal Clojure data structures

{:find [?e]
 :where [[?e !]]}

and finally datomic.Util.read(attr.toString) is substituted in
for the ! symbol
implement a simple Datomic.parseOps using datomic.Util.readAll

simply wrap the Clojure objects up in an anonymous instance of Operation