Mock generator now handles variadic arguments in method

Here is the sample test I used:

```php
<?php

namespace
{
    class foo
    {
        protected $args;

        public function __construct(... $bar)
        {
            $this->args = $bar;
        }

        public function getArgs()
        {
            return $this->args;
        }

        public function bar(... $bar)
        {
            return $bar;
        }

        public function barBis($foo, ... $bar)
        {
            return array_merge(array($foo), $bar);
        }

        public function baz(\stdClass... $baz)
        {
            return $baz;
        }

        public function bazBis(\stdClass $foo, \stdClass... $baz)
        {
            return array_merge(array($foo), $baz);
        }
    }
}

namespace tests\units
{
    use atoum;

    class foo extends atoum
    {
        public function testConstruct()
        {
            $this
                ->given($mocked = new \mock\foo('a', 'b', 'c'))
                ->then
                    ->array($mocked->getArgs())->isEqualTo(array('a', 'b', 'c'))
            ;
        }

        public function testBar()
        {
            $this
                ->given($mocked = new \mock\foo)
                ->then
                    ->array($mocked->bar('a', 'b', 'c'))->isEqualTo(array('a', 'b', 'c'))
            ;
        }

        public function testBarBis()
        {
            $this
                ->given($mocked = new \mock\foo)
                ->then
                    ->array($mocked->bar('foo', 'a', 'b', 'c'))->isEqualTo(array('foo', 'a', 'b', 'c'))
            ;
        }

        public function testBaz()
        {
            $this
                ->given(
                    $mocked = new \mock\foo,
                    $a = new \stdClass,
                    $b = new \stdClass,
                    $c = new \stdClass
                )
                ->then
                    ->array($mocked->baz($a, $b, $c))->isIdenticalTo(array($a, $b, $c))
            ;
        }

        public function testBazBis()
        {
            $this
                ->given(
                    $mocked = new \mock\foo,
                    $foo = new \stdClass,
                    $a = new \stdClass,
                    $b = new \stdClass,
                    $c = new \stdClass
                )
                ->then
                    ->array($mocked->baz($foo, $a, $b, $c))->isIdenticalTo(array($foo, $a, $b, $c))
            ;
        }
    }
}

```
Should be renamed `hasAVariadicParameter`, because the difference between `isVariadic` and `hasVariadic` is not clear. A variadic function has a non-fixed number of arguments, so having `isVariadic` for a parameter is a little bit strange and create confusion. I understand your choice (based on the `ReflectionParameter::isVariadic` method) but I however suggest to rename `hasVariadic`.