(For Jacob) Add support for schemas with type parameters

This PR adds support for parameterized schemas. It allows you to do something like:

```json
{
  "title": "ListReponse",
  "description": "JSON representation of List Response",
  "type": "object",
  "javaType": "com.sift.api.representations.ListResponseJson<T>",
  "properties": {
    "data": {
      "description": "A list of data items",
      "type": "array",
      "required": true,
      "items": {
        "type": "object",
        "javaType": "T"
      }
    },
  }
}
```

which will produce this code:

```java

package com.sift.api.representations;

import java.util.ArrayList;
import java.util.List;
import javax.annotation.Generated;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.google.common.collect.ImmutableList;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.apache.commons.lang3.builder.ToStringBuilder;


/**
 * ListReponse
 * <p>
 * JSON representation of List Response
 * 
 */
@JsonInclude(JsonInclude.Include.NON_NULL)
@Generated("org.jsonschema2pojo")
@JsonPropertyOrder({
    "data"
})
public class ListResponseJson<T >{

    /**
     * A list of data items
     * (Required)
     * 
     */
    @JsonProperty("data")
    @NotNull
    @Valid
    public final List<T> data;

    private ListResponseJson(ListResponseJson.Builder<T> builder) {
        this.data = ((builder.data == null)?null:ImmutableList.copyOf(builder.data));
    }

    @JsonCreator
    private ListResponseJson(
        @JsonProperty("data")
        List<T> data) {
        this.data = data;
    }

    public static<T >ListResponseJson.Builder<T> newBuilder() {
        return new ListResponseJson.Builder<T>();
    }

    public static<T >ListResponseJson.Builder<T> newBuilder(ListResponseJson<T> from) {
        ListResponseJson.Builder<T> builder = new ListResponseJson.Builder<T>();
        builder.withData(((from.data == null)?null:ImmutableList.copyOf(from.data)));
        return builder;
    }

    @Override
    public String toString() {
        return ToStringBuilder.reflectionToString(this);
    }

    @Override
    public int hashCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }

    @Override
    public boolean equals(Object other) {
        return EqualsBuilder.reflectionEquals(this, other);
    }

    public final static class Builder<T >{

        private List<T> data = new ArrayList<T>();

        private Builder() {
        }

        public ListResponseJson<T> build() {
            return new ListResponseJson<T>(this);
        }

        @JsonProperty("data")
        public ListResponseJson.Builder<T> withData(List<T> data) {
            this.data = data;
            return this;
        }
    }

}
```

In order to make Jackson happy, I had to change the means by which it deserializes the json. Before, it was using the builder (as specified via `@JsonDeserializer`). However, Jackson isn't able to instantiate a properly typed builder, so instead we must use a `@JsonCreator` constructor.
Is this still necessary?  It looks like deserialization is handled by a JsonCreator method.