Added Global prototype

This will clean up the code for providing global check and alternatives.
Extracted Warning into warn/Warning

Test case moved to reflect the path change.
Extracted warning handlers into their own prototypes
Corrected tools/combine to handle relative require paths
Combine script now handles relative includes in subdirectories

This is a bit of a kluge, specific to our scenerio, but it works.
FallbackSymbol added

This is the closest we will get to implementing a concept similar to symbols
in pre-ES6. The intent is that, in an ES5 environment, the caller should
ensure that the object receiving this key will mark it as non-enumerable.
Otherwise, we're out of luck.

The symbol string is pseduo-randomly generated with an attempt to reduce the
likelihood of field collisions and malicious Math.{floor,random} overwrites
(so long as they are clean at the time of loading the module).
util/Symbol added
ClassBuilder#build now only making one getMeta call
Corrected MemberBuilderValidator warning handler in class.js
Class ___$$meta$$ moved into private symbol field
Visibility object is now encapsulated in symbol key

Note that this patch temporarily breaks encapsulation via
ClassBuilder.___$$privsym$$ to expose necessary internal details to Trait;
this will be resolved.
Re-encapsulated ClassBuilder private symbol

Temporary method removed and symbol now provided directly to the trait ctor;
this is needed to retrieve the protected visibility object; there is
currently no API for doing so, and there may never be (providing an API for
such a thing seems questionable).

Of course, if we eventually want to decouple the trait implementation from
ClassBuilder (which would be a good idea), we'll have to figure out
something.
createMeta no longer copying to new_class.prototype

I do not wholly recall why this was done initially (nor do I care to
research it, since it's not necessary now), but from the looks of it, it was
likely a kluge to handle a poor implementation of some feature.

This will help clean up a little, since it's rude to pollute a prototype
unnecessarily.
Private symbol key is now non-enumerable

This will, at least in ES5 environments, prevent its general discovery and
[accidental] use. Of course, any decent debugger will still be able to see
it, so unless ES6 is used, this is not truely hidden.
FIXME added for possibly leaking private symbol during tctor call

This is a security-related issue: we want to ensure that the user cannot,
without debugging tools, retrieve certain internal details that may be used
to compromise an implementation.
FallbackSymbol now returns instance of self

Existing functionality is maintained using toString. This is necessary to
support type checking, and to be more consistent with the native Symbol
implementation.

Technically `new FallbackSymbol` is supposed to throw a TypeError, just as
`new Symbol` would, but doing so complicates the constructor unncessarily,
so I am not going to bother with that here.
Began encapsulating internal metadata with symbols

This is a move to solve a couple issues:
  - We shouldn't be adding a ton of non-enumerable stuff to an object---
    defineProperty is slow; and
  - One object containing all internal data (at least in general; more on
    that later) makes ignoring it, copying it, or otherwise operating upon
    it a much easier and cleaner task.