IssueTracker

When writing a parameterized test, it will look something like this:

```
@RunWith(Parameterized::class)
class Benchmark(val size: Long) {

    companion object {
        @JvmStatic
        @Parameterized.Parameters(name = "size={0}")
        fun data(): Array<Long> {
            return arrayOf(10, 100, 1000);
        }
    }

    @get:Rule
    val benchmarkRule = BenchmarkRule()

    @Test
    fun myBenchmark() {
        benchmarkRule.measureRepeated {
            for(i in 0 until size) {
                // Do work
            }
        }
    }
}
```

The output will look something like this

```
{ "results": [
    {
        "name": "myBenchmark[size=10]",
        "classname": "com.test.benchmark.Benchmark",
        "nanos": 279000,
        "warmupIterations": 652,
        "repeatIterations": 1,
        "runs": [ ... ]
    }
}
```

While it is possible to parse the parameterized parameter from the `name` String it is annoying to have to do so. It would be much easier for further post-processing of the results if these parameters had their own block, something like:

```
// Figuring out that the parameter is named `size` would be awesome, but probably not straight forward
{ "results": [
    {
        "name": "myBenchmark[size=10]",
        "params": {
           size: 10
        }
        "classname": "com.test.benchmark.Benchmark",
        "nanos": 279000,
        "warmupIterations": 652,
        "repeatIterations": 1,
        "runs": [ ... ]
    }
}

// This kind of output would still be easier to parse programmatically and is similar to how the parameterized runner approaches it.
{ "results": [
    {
        "name": "myBenchmark[size=10]",
        "params": [10], // Create a parameter array that uses the `{x}` indexes from JUnit.
        "classname": "com.test.benchmark.Benchmark",
        "nanos": 279000,
        "warmupIterations": 652,
        "repeatIterations": 1,
        "runs": [ ... ]
    }
}
```