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'))
                    ->mock($mocked)
                        ->call('__construct')->withArguments('a', 'b', 'c')->once
            ;
        }

        public function testBar()
        {
            $this
                ->given($mocked = new \mock\foo)
                ->then
                    ->array($mocked->bar('a', 'b', 'c'))->isEqualTo(array('a', 'b', 'c'))
                    ->mock($mocked)
                        ->call('bar')->withArguments('a', 'b', 'c')->once
            ;
        }

        public function testBarBis()
        {
            $this
                ->given($mocked = new \mock\foo)
                ->then
                    ->array($mocked->barBis('foo', 'a', 'b', 'c'))->isEqualTo(array('foo', 'a', 'b', 'c'))
                    ->mock($mocked)
                        ->call('barBis')->withArguments('foo', 'a', 'b', 'c')->once
            ;
        }

        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))
                    ->mock($mocked)
                        ->call('baz')->withArguments($a, $b, $c)->once
                ->given($arrayOfStdClass = array($a, $b, $c))
                ->then
                    ->array($mocked->baz(... $arrayOfStdClass))->isIdenticalTo(array($a, $b, $c))
                    ->mock($mocked)
                        ->call('baz')->withArguments($a, $b, $c)->twice
            ;
        }

        public function testBazBis()
        {
            $this
                ->given(
                    $mocked = new \mock\foo,
                    $foo = new \stdClass,
                    $a = new \stdClass,
                    $b = new \stdClass,
                    $c = new \stdClass
                )
                ->then
                    ->array($mocked->bazBis($foo, $a, $b, $c))->isIdenticalTo(array($foo, $a, $b, $c))
                    ->mock($mocked)
                        ->call('bazBis')->withArguments($foo, $a, $b, $c)->once
                ->given($arrayOfStdClass = array($foo, $a, $b, $c))
                ->then
                    ->array($mocked->bazBis(... $arrayOfStdClass))->isIdenticalTo(array($foo, $a, $b, $c))
                    ->mock($mocked)
                        ->call('bazBis')->withArguments($foo, $a, $b, $c)->twice
            ;
        }
    }
}

```