Introduce support for gwt_binary().

Summary:
Implement `gwt_binary()` as a result of the discussion at:
https://github.com/facebook/buck/issues/109

Using `gwt_binary()` looks like the following:

```
gwt_binary(
  name = 'my_app',
  modules = [
    'com.example.client.TheClient', # GWT module to build.
  ],
  style = 'PRETTY',
  draft_compile = True,
  optimize = 0,
  local_workers = 4,
  module_deps = [
    # List of java_library() build targets that function as GWT modules.
  ],
  deps = [
    # Traditional deps.
    # One of these should be a java_library() (or prebuilt_jar()) rule that
    # has the definition of the com.google.gwt.dev.Compiler class.
  ],
)
```

For each Java library (i.e., `java_library()` or `prebuilt_jar()`) in `module_deps`,
a source JAR is generated and is included on the classpath when running
the GWT compiler. Therefore, building a `gwt_binary()` does not entail
running `javac` to build each of the rules listed in `module_deps`. If you want
to make sure that `javac` is run for your library, you can always list your Java library in `deps`.
(In the future, I will probably add an argument to `gwt_binary()` to specify
whether `module_deps` get built like regular deps.)

Note that the rules in the `module_deps` list will likely want to include their
`.gwt.xml` files as Java resources. As such, you might want to define the following
macro in your build:

```
import copy

def gwt_module(
    gwt_xml=None,
    **kwargs
    ):
  """A GWT library is defined by its .java source code, a .gwt.xml module file, and resources."""
  java_kwargs = copy.copy(kwargs)
  if not 'resources' in java_kwargs:
    java_kwargs['resources'] = []
  if gwt_xml:
    java_kwargs['resources'] += [gwt_xml]
  java_library(**java_kwargs)
```

Going forward, whether we support a `gwt_module()` rule or just add a `gwt_xml` argument to `java_library()`
is open for debate. For now, we would like to add support for GWT while introducing as few
new concepts as possible to Buck.

This diff also introduces a `gwt_jar` argument to `prebuilt_jar`. This is useful for
defining Guava:

```
prebuilt_jar(
  name = 'guava',
  binary_jar = 'guava-17.0.jar',
  source_jar = 'guava-17.0-sources.jar',
  gwt_jar = 'guava-gwt-17.0.jar',
  visibility = [
    'PUBLIC',
  ],
)
```

This is imperative when you have an alternative GWT implementation of a Java library.
Specifically, when you have one implementation that contains JSNI, and one implementation that
contains an implementation that cannot be translated to JS by the GWT compiler.

Finally, here is an example of using macros to create "debug" and "release" targets for the same GWT application:

```
java_library(
  name = 'debug_module',
  resources = [ 'Example_debug.gwt.xml', ],
)

java_library(
  name = 'release_module',
  resources = [ 'Example_release.gwt.xml', ]
)

def create_gwt_binary_rules(name):
  for is_debug in [True, False]:
    gwt_binary(
      name = name + '_' + ('debug' if is_debug else 'release'),
      style = 'PRETTY' if is_debug else 'OBF',
      draft_compile = is_debug,
      optimize = 0 if is_debug else 9,
      local_workers = 3 if is_debug else 8,
      modules = [
        'com.example.Example_' + ('debug' if is_debug else 'release'),
      ],
      module_deps = [
        # List the common module_deps here.
      ] + [':debug_module' if is_debug else ':release_module'],
      deps = [
        # List the common deps here.
      ],
    )

# Creates :example_debug and :example_release.
create_gwt_binary_rules('example')
```

Test Plan: Retrofit an existing GWT application with `BUCK` build files and build it using Buck.