Java

Add support for Java.  Currently only supports the openJDK versions available via apt-get.
We should arguably be able to have a `.boxci.yml` that looks something like the following:

```yaml
rbenv:
  - 2.1.2
  - 2.1.3
  - 2.1.5
jvm:
  - 1.2.3
  - 1.2.4
  - 1.2.5
```

If that was the case the permutations would be the following

- Ruby 2.1.2 with JVM 1.2.3
- Ruby 2.1.2 with JVM 1.2.4
- Ruby 2.1.2 with JVM 1.2.5
- Ruby 2.1.3 with JVM 1.2.3
- Ruby 2.1.3 with JVM 1.2.4
- Ruby 2.1.3 with JVM 1.2.5
- Ruby 2.1.5 with JVM 1.2.3
- Ruby 2.1.5 with JVM 1.2.4
- Ruby 2.1.5 with JVM 1.2.5

So the idea however fleshed out was that the `ProjectConfig#permutations` method would return back an array of `Boxci::ConfigPermutation` objects and each `Boxci::ConfigPermutation` object would have *N* `Boxci::ConfigPermutationComponents` in it.

I did some playing and it looks like we can get the component combinations using something like the following:

```ruby
[rbenv_components, jvm_components].inject(&:product).map(&:flatten)
```

So we of course would have to build up an array called `rbenv_components` of all the rbenv components specified in the config, and an array of `jvm_components` specified in the config first.

An example in irb to show the production of product appropriately.

```ruby
irb(main):002:0> [['a', 'b', 'c'], [1, 2, 3]].inject(&:product)                                                        
=> [["a", 1], ["a", 2], ["a", 3], ["b", 1], ["b", 2], ["b", 3], ["c", 1], ["c", 2], ["c", 3]]
irb(main):003:0> [['a', 'b', 'c'], [1, 2, 3]].inject(&:product).map(&:flatten)
=> [["a", 1], ["a", 2], ["a", 3], ["b", 1], ["b", 2], ["b", 3], ["c", 1], ["c", 2], ["c", 3]]
irb(main):004:0> [['a', 'b', 'c'], [1, 2, 3]].inject(&:product)
=> [["a", 1], ["a", 2], ["a", 3], ["b", 1], ["b", 2], ["b", 3], ["c", 1], ["c", 2], ["c", 3]]
irb(main):005:0> [['a', 'b', 'c'], [1, 2, 3], ['bob', 'cindy', 'alice']].inject(&:product)
=> [[["a", 1], "bob"], [["a", 1], "cindy"], [["a", 1], "alice"], [["a", 2], "bob"], [["a", 2], "cindy"], [["a", 2], "alice"], [["a", 3], "bob"], [["a", 3], "cindy"], [["a", 3], "alice"], [["b", 1], "bob"], [["b", 1], "cindy"], [["b", 1], "alice"], [["b", 2], "bob"], [["b", 2], "cindy"], [["b", 2], "alice"], [["b", 3], "bob"], [["b", 3], "cindy"], [["b", 3], "alice"], [["c", 1], "bob"], [["c", 1], "cindy"], [["c", 1], "alice"], [["c", 2], "bob"], [["c", 2], "cindy"], [["c", 2], "alice"], [["c", 3], "bob"], [["c", 3], "cindy"], [["c", 3], "alice"]]
irb(main):006:0> [['a', 'b', 'c'], [1, 2, 3], ['bob', 'cindy', 'alice']].inject(&:product).map(&:flatten)
=> [["a", 1, "bob"], ["a", 1, "cindy"], ["a", 1, "alice"], ["a", 2, "bob"], ["a", 2, "cindy"], ["a", 2, "alice"], ["a", 3, "bob"], ["a", 3, "cindy"], ["a", 3, "alice"], ["b", 1, "bob"], ["b", 1, "cindy"], ["b", 1, "alice"], ["b", 2, "bob"], ["b", 2, "cindy"], ["b", 2, "alice"], ["b", 3, "bob"], ["b", 3, "cindy"], ["b", 3, "alice"], ["c", 1, "bob"], ["c", 1, "cindy"], ["c", 1, "alice"], ["c", 2, "bob"], ["c", 2, "cindy"], ["c", 2, "alice"], ["c", 3, "bob"], ["c", 3, "cindy"], ["c", 3, "alice"]]
irb(main):007:0>
```

**Note:** The way I am producing the product above you can't have an empty array of components in the overall array or the product combination computation won't work properly and you will end up with an empty set.

So pseudo code I was thinking something like the following for the `permutations` method.

```ruby
    def permutations
      # collect an array of all of the rbenv permutation components
      # collect an array of all of the jvm permutation components
      # compute the permutation component combinations using the array of rbenv components and array of jvm components. Note: Only include array if not empty
      # map the component combinations array to an array of permutation object
      # return the array of permutation objects
    end
```