Standardize on kw_args over keyword_args.

It's a bit shorter but still obvious what it means.
Refactoring: extract MethodSignature class.

- The signature of a method is a concept in its own
  right and deserves to be represented as its own object.
- This gives a clear delineaziation of responsibilities
  between extracting method signature info and verifying
  arguments against that info.
- The new `classify_parameters` approach should perform
  a bit better than what we had before; it iterates over
  `method.parameters` once total where as before it would
  iterate over it 3 times.
Add missing test.

A last-arg hash should only be treated as kw args if the method has kw arg params.
Clean up `split_args` a bit.

- It was odd to have it memoize internally but accept an arg.
- Simpler just to call it once in `initialize`.
Decrease syntactic noise of argument lists.

I find this:

foo(nil, :a => 1)

...to be much less noisy than this:

foo([nil, { :a => 1 }])

The first form more closely matches how people pass args
and kw args to methods, anyway.
Refactor: prep for supporting `**kw_args`.

To support `**kw_args`, `allowed_kw_args` will have
to act like an infinite set. Rather than making the
verifier (and any future clients) responsible for
dealing with this special case, it's simpler to move
the invalid/missing kw arg calculations into
`MethodSignature`, where it can handle that special
case internally.
Add support for `**kw_args` parameters.
We can't count on `is_a?` working on every argument.

BasicObject, for example, does not respond to it.
It's safer to use `SomeClass === obj` than `obj.is_a?(SomeClass)`.
Don't mutate the provided args array.

Mutating could lead to surprises for the caller.
Replace multiple conditionals with a single case statement.
`error` => `error_message`

It's not a ruby error object, it's just the message,
so the new name is more accurate.
Update method names, etc to reflect our check is more than arity.

Arity is just the number of arguments but we check
more than that now, so it's good to reflect that.
Rename method.

It's a description of the arity so let's call it that.
Refactor: make caller pass a signature object.

This clears the way to use a slightly different
signature implementation (e.g. for blocks).
Reword docstrings.

I'm about to introduce a new `description` method
and having docstrings say "it is described precisely"
when not referring to the description is confusing.
Use method signature verifier for `and_yield` block verification.
Merge pull request #548 from rspec/improve-method-signature

Improve method signature / argument validation