Implement turnip snippets generation and make it default

Starting from this commit, every time you do `--init`, behat will generate
a context class, that implements `TurnipSnippetsFriendlyInterface`. There
are two interfaces like that:

- `RegexSnippetsFriendlyInterface` - v2-like regex-based definitions
- `TurnipSnippetsFriendlyInterface` - turnip-like definitions

Those interfaces have 2 purposes:

1. Tell behat that this context class expects snippets. This means from now
   on, every time you run `--append-snippet` behat will append them only to
   the context that implement one of those interfaces
2. Tell behat which particular type of definitions syntax you want to use.
   Because starting from 3.0, there are two!

We all know that nobody can beat flexibility of regexps. That's why they are
still here in behat and will stay for versions ahead. But flexibility always
comes at a cost - especially with regexps.  Readability suffers a lot even
when you define a simplest patterns. Also, regular expressions are kinda
legendary for their ability to scare both newcomers and code masters like
@weaverryan :) So that's why starting from 3.0, default behavior for your
initial context would be to use Turnip-style snippets.

What is turnip-style snippet? Well, it's a placeholder-based texts which you
can use to write your definition matchers:

    /**
     * @Given there is a book called :name
     */
    public function thereIsABookCalled($name)
    {
    }

Such definition would match any of the following steps:

1. Given there is a book "Gang of 4"
2. Given there is a book 'Gang of 4'
3. Given there is a book Gang of 4

In 1st and 2nd options, `$name` inside your definition would be equal to
`Gang of 4`. 3rd option will cause `$name` to be set to `Gang`. So basically
it does not matter which kind of quotes you use or if you use them at all if
you have one-word value :)

And of course, life would not be full without alternatives and optional word
endings:

    /**
     * @Given there is/are :count book(s)
     */
    public function thereIsABookCalled($count)
    {
    }

Such definition would match any of the following steps:

1. Given there is 1 book
2. Given there are 3 books

From time to time, you'll most likely get that complex definition, which is
really hard to capture with turnip. In this case, you would be happy to discover
that behat does not case if you have multitype snippets in one context:

    /**
     * @Given there is/are :count book(s)
     */
    public function thereIsABookCalled($count)
    {
    }

    /**
     * @When /^I (add|delete) (last|first) book$/
     */
    public function iDelete($action, $index)
    {
    }

You can use both turnip-style and classical regex-based definitions in all
your contexts whenever you want. `*FriendlyInterface`(s) are merely here to
tell behat which kind of snippets it should autogenerate for you.

As a last bit if you noticed, turnip-style placeholders are always named.
It basically means that behat will match placeholders to definition arguments
by name rather than order. Meaning that it does not matter in which order do
you put your definition arguments while they match placeholder names.

This also means that if you use turnip-style patterns, you also can use
placeholder-name-based transformations:

    /**
     * @Transform :count
     */
    public function transCountToInt($count)
    {
        return intval($count);
    }

    /**
     * @Given there is/are :count book(s)
     */
    public function thereIsABookCalled($count)
    {
        // $count is an integer now
    }

Turnip-style patterns were highly influenced by https://github.com/jnicklas/turnip