Change StormTopology state serialization from Java to Thrift

config and nimbus currently use the core Java serialization to store
StormTopology instances. This commit will change this to use Thrift
serialization instead. StormTopology is a Thrift struct so this
basically involves finding all the places we call `Utils/serialize` and
`Utils/deserialize` and replace them with a call to a method that
serializes with Thrift instead.
Move serialization of Storm conf from Java default to Clojure default

config.clj and nimbus serialize Storm configuration using the default
Java implementation. This commit will phase out Java default
serialization in favor of Clojure default serialization. There are
obviously many reasons to phase out Java serialization, but the main
rationale is that Java serialization will complain about version
mismatch even if the change is semantically backward compatible.
Fix serialization concurrency bug

TSerializer is not threadsafe. In `Utils` we instantiate a static final
Tserializer, but this can (and will) cause odd bugs if we start calling
`serialize()` in different threads. Thus, every time we call
`Utils/serializeTopology`, we create a new TSerializer.

Another way to do this would be to lock it, which performance may or may
not merit.
Make serialization funcitons more generic

Serialization of configuration is handled in config, but it is not
different from a generic method for Clojure form serialization. This
commit will move this method to utils so that we can use it for other
things, like serialization in cluster.
Transition cluster state serialization to Clojure form serialization

cluster.clj uses the stock Java serialization implementation. There are
obviously many reason to not use standard Java serialization, but our
main motivation is that Java will complain about serialized state
when the versions don't match even if they're semantically backwards
compatible.
Source LocalState serialization logic to state serialization interface

Supervisor currently just uses stock jvm serialization to communicate
LocalState. This is undesirable for many reasons, so this commit
will introduce a serialization interface which makes code cleaner,
letting us specify which type of serializer to use without populating
Supervisor with unnecessary boxing/unboxing behavior, or LocalState
with too much knowledge about what's happening in the Supervisor.

Also this commit will introduce a basic implementation sketch for a
serializer for LocalState (though it will just use the jvm serialization
at this point).
Source LocalState constants to Constants.java

To build the serialization interface in Java, we need to put these
constants in a Java file. This commit will put them in Constants.java
Add sketch of LocalStateSerializer
Add clojure-based serialization implementation for LocalState
Update Supervisor to use clojure serialization
Require LocalState to take a serializer in constructor
Remove Java implementation of LocalStateSerializer
Fixup for rebase of hausdorff/ser_dev onto nathanmarz/master