Rewrite & functionality upgrade

Total rewrite of the engine and a lot of API improvements.

_Following list is by no means complete descriptions of changes_
* Internal object bindings redesign
  * No more infinitely nested descriptors. There's rich descriptor for
each object property, and plain descriptor (just value and modification
date) for descriptor property. It doesn't extend further.
  * Introduced nested objects that can be nested infinitely, e.g.
`obj.objProp.objProp.objProp` etc. It allows configuration of objects
which existence doesn't make sense without its owner (e.g. _address_
property).
  * Multiple item is no longer a descriptor to which custom properties
can be assigned, It's plain descriptor that holds just value and
modification date (same as descriptor of object's property descriptor's
property)
  * Prototype chain is no longer build in full for created objects. Only
objects that must be created (as they hold other properties or value)
are created. If prototype objects of existing objects are introduced
later, they're injected in proper places of prototype chain. That should
largely reduce number of objects that was created in old design.
  * Access of property doesn't force creation of corresponding descriptor,
again it reduces number of objects that were created in old design.
  * Database handled properties can be freely mixed or overwritten by
natively defined values (via e.g. `Object.defineProperty`). It makes dbjs
handling an opt-in, and can vastly be reduced when no changes to some
properties (e.g. schemas) are not expected or allowed.
  * Introduce descriptor prototype concept. Through which we can define
characteristics for all properties of given object. Use case is when
object is not closed set of properties, but expandable dictionary of
key => value pairs where each value shares same characteristics (same
type, same singular/multiple setting etc.)
  * Brand new property value resolution algorithm.
  * There's no more proto (mother of all) object, instead there are now
four prototypes, that have same base API and are extended further into
any dbjs objects:
      * object (extends from `Map.prototype` can be accessed as
`Base.prototype`)
      * property descriptor (extends from `Map.prototype` can be accessed
as `Base.prototype.__descriptorPrototype__`)
      * property descriptor of property descriptor (extends
`Object.prototype` can be accessed as
`Base.prototype.__descriptorPrototype__.__descriptorPrototype__`)
      * multiple item (extends `Object.prototype` can be accessed as
`Base.prototype.__itemPrototype__`)
* Objects are maps (instances of extension of native `Map`) and accept
keys of any valid database values. String keys are exposed as properties
of object (if they do not collide with native properties).
* Removed weird _relation transport_ (`Type.rel`) concept, which allowed
to set properties with all meta characteristics. Instead _set_ and
_define_ functionalities are split and served by different methods.
`define` and `defineProperties` allows definition of properties with all
descriptor characteristics. `set` and `setProperties` accept only plain
values. `define` method throws if called for already defined property, it
will help to early detect any property name collision in large schemas.
* Improved error handling, now all error messages that come out of batch
operations (as e.g. `setProperties`) are descriptive and provide
information about underling errors.
* By default each database value is resolved on demand, and for each value
optional observer (that forces constant resolution and up to date
notification) can be created.
* In previous design descriptor and observer functionality where provided
by one object (accessed as `obj._foo`). In new design descriptor and
observer are different object, descriptor can be accessed via `obj.$foo`
an observer via `obj._foo`.
* Changes of properties on given objects can be observed from object
perspective (object implements `observable-map` interface). This
functionality is off by default, and turnd on as soon as first listener on
the object is attached.
* Events are propagated only after all internal changes to data structure
are made. Thanks to that listeners are not called in uneven state (when
some values may not be of expected type or some objects may not exist yet).
This should fix most race condition issues and allows to write code
without race condition awareness that was mandatory in old design.
* Remove internal observable set, list (array) etc pseudo-implementations,
and use dedicated `observable-set`, `observable-map`, `observable-array`
that stand on native types
* Remove _fragment_ functionality, it'll be re-introduced with external package