route(scope, name, targetScope, targetName) {
    const scopeObject = getScope(this, scope);
    const targetScopeObject = getScope(this, targetScope);
    const privateName = '_' + name;

    Object.defineProperties(scopeObject, {
      // A private property is defined to hold the actual value, when this property is set in its scope (set in the setter)
      [privateName]: {
        value: scopeObject[name],
        writable: true
      },
      // The actual property is defined as getter/setter so we can do the routing when value is not locally set.
      [name]: {
        enumerable: true,
        get() {
          const local = this[privateName];
          const target = targetScopeObject[targetName];
          if (isObject(local)) {
            return Object.assign({}, target, local);
          }
          return valueOrDefault(local, target);
        },
        set(value) {
          this[privateName] = value;
        }
      }
    });
  }
Routes the named defaults to fallback to another scope/name.
This routing is useful when those target values, like defaults.color, are changed runtime.
If the values would be copied, the runtime change would not take effect. By routing, the
fallback is evaluated at each access, so its always up to date.

Example:

	defaults.route('elements.arc', 'backgroundColor', '', 'color')
  - reads the backgroundColor from defaults.color when undefined locally

@param {string} scope Scope this route applies to.
@param {string} name Property name that should be routed to different namespace when not defined here.
@param {string} targetScope The namespace where those properties should be routed to.
Empty string ('') is the root of defaults.
@param {string} targetName The target name in the target scope the property should be routed to.