crawltree: Working version of tree layout

New array-add-stragglers helper method rebuilds clojure
map from d3 object modifications.
project: calling cljs output strokes-main.js

So that the d3patch can be prepended to create
the final strokes.js file.
examples: first (sloppy) versoin of convex hull

working without mouse input. initially sloppy - use of defs etc
(with the exception of putting the circles in an atom already).

Also added the now released d3.v3.js files to the repo. Also
had to comment out global def messiness in the still under
development crawltree example. Finally, added an empty
deps.js to prevent missing file, etc.
hull: vertices now stored as vector in atom
hull working: wip
hull: now working with mouse input - though still sloppy

This is a functional port of the convex hull d3 example.
It is still a little sloppy because most things are defined
as globals via def.
clocky: renamed to examples.clocky

Let's put all the examples in their own namespace
hull: example cleaned up and localized to launch function
examples: moved to strokes.examples.* namespace
strokes: first working example of metaprogramming with d3

In the hull example, the d3.geom.hull method is given an
array of patched cljs vectors with minimally metaprogrammed
accessors for the elements 0 and 1, as well as a length
method and an updated toString method. d3.geom.hull used
this to unwittingly generate a new array of cljs vectors
which are then passed off to be drawn.

The same array of patched cljs vectors is given to the
.data call to draw the circles directly. In both cases,
the objects are accessible as read-only elements and
generate the correct string representation to generate
the svg needed.

Now will generalize the patch-vector call and look into
making a similar method for the top level seq to also
eliminate the (apply array) call.
mrhyde: patching all clojure datatypes at once!

By patching the persistent vector prototype (__proto__
member actually), we magically can get rid of all
strokes/patch-vector calls. This is pretty huge.
The 7 lines of magic in fact will be repeated here:

  (let [v [1, 2]
        p (.-__proto__ v)]

    (.__defineGetter__ p "length" #(this-as t (count t)))
    (dotimes [n 100]
      (.__defineGetter__ p n #(this-as t (nth t n js/undefined))))
    (-> p .-toString (set! #(this-as t (clojure.string/join ", " t)))))

This is run at launch time and effectively patches all persistent
vector type to pretend to be arrays good enough for the d3 interop
needed for the hull example.

Ideally, the getters for the individual elements would be installed
based on the length. This should be possible in the future by
intercepting the constructor, but for now this 100 loop kludge
serves fine.

Now let's try the same thing on the seq. Then finally, we can
try to patch the return value of d3.mouse so that all the
interop noise will be gone.
mrhyde: now patching several seq types with js array interface

With latest patching on seqs, we no longer need to (apply array foo).
For the hull example, this means that the seq of vertices can
be passed directly to d3.

Ironically, this broke the original d3.data patch somehow,
but that's just as well because it is no longer needed.
However, we can still try to patch the library return values,
which we will do next.
strokes: patches d3.mouse to return clj data

Dude, where's my interop code?
cleanup: Removing d3 patches and renaming output to strokes.js

Tidying up for posting the hull example.