Support property node references in `kernel.createChild`.

Support properties containing node references in `kernel.createChild`,
in addition to `kernel.setNode`. Node references are only valid during
replication, but properties of nodes created during replication are
assigned in `kernel.createChild` and not `kernel.setNode`.

Node references are property descriptors in the form:

    { properties: { p: { node: id } } }

This is in contrast with regular property values, which have descriptors
in the form:

    { properties: { p: { value: v } } }
Accept node references in `node.children.create` component descriptors.

References #3088.
Support namespaced events to be used for node meta events.

Namespaced events will allow the kernel to use the normal event
listening/firing mechanism for meta events that are distinct from a
node's regular events.

Meta events will announce changes to a node, such as adding and removing
children, creating and deleting properties, methods and events, etc.

References #3094.
Attach meta events to the node collection objects.

References #3079.
Send meta events from the kernel.

References #3080, #3077.
Suppress kernel reentry for meta events during replication.
Track globals in the node registry.

Keep track of which nodes are roots in the global space (such as the
application, other reflector-created trees such as `clients.vwf` and the
prototypes). Add the node name to the registry.

This is to allow locating extra-application trees by URI and by
annotation (name).
Add `kernel.globals`, `kernel.global` and `kernel.root`.

`globals` returns the set of root nodes of the application and the other
global trees. `global` locates a tree by URI or annotation. `root`
locates the root of the tree containing a reference node.
Identify the application tree using the node registry.
Add `kernel.child`. Add `initializedOnly` to child functions.

- Since `kernel.children` has the global analogue `kernel.globals`, add
  `kernel.child` for consistency with `kernel.global`. `kernel.child`
  locates a child by index number or name.

- Add `initializedOnly` protection to the downward query functions
  `kernel.children` and `kernel.descendants`.

  When enabled, `initializedOnly` in `kernel.parent` and
  `kernel.ancestors` guards against references out of uninitialized
  nodes. In `kernel.children` and `kernel.descendants`, it guards
  against references into uninitialized nodes.

  Similarly, `initializedOnly` in `kernel.globals` and `kernel.global`
  guards against references into uninitialized trees. In `kernel.root`,
  it guards against a reference out of the current tree into the global
  space when the current tree is not yet initialized.
Use `kernel.root` instead of `kernel.application` for the `find` root.

Use `kernel.root` to locate the node corresponding to `node.find( "/" )`
to allow `find` and `test` to work if the context is a non-application
tree.
Support XPath `doc` for locating trees outside the application.

In an XPath query, `doc(uri)` or `doc(annotation)` locates the root of a
tree loaded from the given URI or assigned the annotation. A URI or
annotation that doesn't look like an XPath QName must be quoted.

- `node.find( "/" )` locates the application root.

- `node.find( "doc('application')" )` or `node.find( "doc(application)" )`
  locates the application root through the `"application"` annotation.

- `node.find( "doc('http://vwf.example.com/clients.vwf')/" ) locates the
  root of the clients tree.
Clarify `kernel.createNode` comments.

Describe slightly better how a URI is loaded to transform into a
descriptor and is then constructed to transform into an ID. `createNode`
will accept a component in any of the three forms and will walk it
through the remaining steps.
Deprecate `kernel.findClients` in favor of `kernel.find` with `fn:doc`.

References #3085.