reworked Vector classes, no change in API, reordered methods, divide-by-zero prevention, removed use of .set() in methods for better performance

Added translate( distance, axis ), translateX( distance ), translateY( distance ) and translateZ( distance ) methods to Object3D.
Camera3D translate method overrides Object3D's one. NoFly parameter removed (this should be handled from outside I think).

Object3D::lookAt works! (and Vector3.setRotationFromMatrix too!)

Next: Object3D::translate...

WebGLRenderer checks if texture is power of 2. Throws an error if it's not.

I don't remember when was the last time I used them. Current Web Developer Tools do this already for you.

Color::updateRGBA ⟶ Color::updateRGB

- getters/setters are no more in Vector3
  - object hierarchies thus don't use "isDirty"
  - this was completely killing performance for anything that was touching a lot of Vector3 like creation of meshes and dynamic buffers
  - even without this, performance of hierarchies went up (a lot)

- objects do not get passed renderer anymore
  - camera was almost also removed, but this is useful for LOD (though there may be some cleaner way to do this?)

- material ids are now unified, this makes "geometry.sortFacesByMaterial" faster (thus scene init / GUI blocking is shorter)

- all WebGL examples should work now (render-to-texture has weird lights and in some camera control feels different)

- CanvasRender still broken, despite many efforts :(
   - currently only points and lines work, faces don't show up. I think this may need assistance from mrdoob.

We have been very lucky - setters / getters were not supported till just 2 hours ago (so fresh, I had to build Closure myself from their repo ;).

http://code.google.com/p/closure-compiler/issues/detail?id=249

Also some refactoring plus added hackish animation offset feature.

Otherwise things are very much work in progress, expect everything to be broken.

TODO: Add computeVertexNormals on geometry so any object can use it.

* `CanvasRenderer` and `SVGRenderer` basic lighting support (`*ColorStroke`/`*ColorFill` only)
* `Renderer` > `Projector`. `CanvasRenderer`, `SVGRenderer` and `DOMRenderer` do not extend anymore
* Interactivity base code (hdi folder). To be refactored... ([mindlapse](http://github.com/mindlapse))
* Added `computeCentroids` method to `Geometry`
* Included `Stats.js` directly in the `/examples` folder to avoid the need of internet for playing around

  * Added getCenter to Face4

* Additional `Matrix4` and `Vector3` methods

* `Face4` now supports `MeshBitmapUVMappingMaterial`
* Changed order of `*StrokeMaterial` parameters. Now it's `color`, `opacity`, `lineWidth`.
* `BitmapUVMappingMaterial` > `MeshBitmapUVMappingMaterial`
* `ColorFillMaterial` > `MeshColorFillMaterial`
* `ColorStrokeMaterial` > `MeshColorStrokeMaterial`
* `FaceColorFillMaterial` > `MeshFaceColorFillMaterial`
* `FaceColorStrokeMaterial` > `MeshFaceColorStrokeMaterial`
* `ColorStrokeMaterial` > `LineColorMaterial`
* `Rectangle.instersects` returned false with rectangles with 0px witdh or height

Old Vector and Matrix constructor functions would create all methods and
make assignments with each call. A lot of speed-ups can be made by using
shared properties through the prototype chain. Since methods and
initialized properties are shared among all instances they're only
created once.

Some tests can be seen at examples/performance-test.html

Some results:

    Chrome

    //6.4 times faster
    performance-test.html:25 Vector2 x 5000000: 213ms
    performance-test.html:30 Vector2Orig x 5000000: 1366ms

    //8.3 times faster
    performance-test.html:37 Vector3 x 5000000: 241ms
    performance-test.html:42 Vector3Orig x 5000000: 2015ms

    //3.8 times faster
    performance-test.html:49 Vector4 x 5000000: 278ms
    performance-test.html:54 Vector4Orig x 5000000: 1059ms

    //7.5 times faster
    performance-test.html:61 Matrix4 x 5000000: 937ms
    performance-test.html:66 Matrix4Orig x 5000000: 7004ms

    Firefox

    //6.8 times faster
    Vector2 x 50000: 45ms
    Vector2Orig x 50000: 307ms

    //11.5 times faster
    Vector3 x 50000: 48ms
    Vector3Orig x 50000: 550ms

    //3.8 times faster
    Vector4 x 50000: 61ms
    Vector4Orig x 50000: 234ms

    //9.4 times faster
    Matrix4 x 50000: 199ms
    Matrix4Orig x 50000: 1878ms

where "Orig" are old versions of the objects.

Running these tests multiple times can yeild different results due to
browser cache. However the results are always kind of similar in terms
of speedup.

- Simplified lookAt in Matrix4
- Added cross() in Vector3

- Object3D.overdraw = true to enable CanvasRenderer screen space point expansion hack.

- CanvasRenderer supports TextureUVMappingMaterial.
- Moved UVs to Geometry.
- Minor clean up

+ Workaround for WebKit not supporting rgba() in SVG yet
+ Aesthetic changes on the readme file

Vector3.cross -> crossSelf
added Vector3.multiplySelf and others (kile)

Added THREE namespace
Camera.x -> Camera.position.x
Camera.target.x -> Camera.target.position.x
ColorMaterial -> ColorFillMaterial
FaceColorMaterial -> FaceColorFillMaterial
Materials are now multipass (use array)
Added ColorStrokeMaterial and FaceColorStrokeMaterial
geometry.faces.a are now indexes instead of links