Fix the `["name"]` case. Interpret `[]` as namespaced, distinct from `""`.

References #3076.
A kernel utility module.
Translate between kernel and model/javascript node references.

The translation is performed for each value (property value, method or
event parameter, or return value) that crosses between the kernel and
the model/javascript driver. This allows components to make persistent,
direct node references. Nodes may be assigned to properties and passed
through methods and events.

References #3088.
Replicate node references.

Regular properties replicate as `{ propertyName: value, ... }`, or the
more general `{ propertyName: { value: value }, ... }`. Extend the
general form to encode properties containing node references as `{
propertyName: { node: nodeID }, ... }`.

The `node` field indicates that the property is a node reference instead
of a simple value. Using a distinict field ensures that the reference
won't be confused with any other value that could otherwise resemble a
node ID.

References #3088.
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.
Factor out `parametersKernelFromJS` and `parametersJSFromKernel`.

References #3088.
Clarify names that reference the proto-prototype node `node.vwf`.

Rename the `kernel/utility` items `nodeTypeURI` and `nodeTypeDescriptor`
to `protoNodeURI` and `protoNodeDescriptor`, respectively, to better
reflect that they refer to the proto-prototype node.

Rename the `model/javascript` internal variable `nodeNode` to
`protoNodeNode` so that it parallels the `protoNodeURI` name it derives
from and to hopefully clarify that it is the `model/javascript`
`...Node` data for the `protoNode...` node.

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.
Comments.
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.