Moves argument in-parser name from Command.parse to Arg.parser_name

And adds some tests on it.
Allows positional arguments to be optional

They're pretty common nowadays in a git-like fashion:

program list [expression [limit]]

$ program list
$ program list expression
$ program list expression limit

This is because of

     @property
     def parser_name(self):
         return self.name if self.required else '--%s' % self.name

which automatically turns non-required arguments into options by adding
-- to its name.

So

	parser.add_argument('name', nargs='?', default=None)

which parses

	$ program value    OK
	$ program          OK

it's detected as non-required and transformed into

	parser.add_argument('--name', nargs='?', default=None)

	$ program value    ERROR
	$ program --name   WRONG

There is no way to detect optional positional arguments inspecting a function
definition. If they have a default value, they'll be options.

To solve this a 'positional' class has been added, which makes users
able to mark a kwargument or option as positional in a declarative
fashion.

Examples:

	def list(expression=positional('.*'), limit=positional(500)):
		pass

or

	@manager.arg('limit', default=positional(500))
	@manager.arg('expression', default=positional('.*'))
	@manager.command
	de list(expression, limit):
		pass
Refactors Command.inspect and adds extra tests

Moves inspection responsability to a InspectedFunction class