Make Context argument optional

This is a (very hacky) implementation for #10 . I am relatively new to Go, and this was an interesting problem, so I wanted to find out if this was possible. Again, this is probably a horrible abomination, but it works.

## How it works
This PR makes the `Action` parameter it's own interface, with two implementing struct types: `ContextAction` and `PlainAction`. When passing in a `func` to `app.SetAction` or `command.SetAction`, they as `ParseAction` for an Action for the field. `ParseAction` prints the `func` to a string using `Sprintf` and then performs a simple RegEx to check if the function has any arguments (currently, it matches any non-whitespace character and does not count arguments, only checks if there is any at all). If it has, it returns a `ContextAction` with the `func(*Context)` attached, else it returns a `PlainAction` with a plain old `func()` attached. The action can then be called using the `Execute(*Context)` function of the `Action` interface. Here is the HelloWorld:

``` go
package main

import "os"
import "github.com/codegangsta/cli"

func main() {
  app := cli.NewApp().SetAction(func(){println("Hello World!")}).Run(os.Args)
}
```

## Why this works
For debugging purposes, `func` exports the ability to print to string so that we can see what function an error is referring to and information about it. `Sprintf` calls that ability, giving us that same string we would see in an error output message (looks like `%sfunc(*Context)=0x398c4)`). We can then check the string with Regex for its arguments.

## Should this be used?
Probably not (like 99% sure). It's not really type safe (uses `inteface{}` to accept both `func` types). There's a reason this is so hacky and that's because it's not really what Go is for. Go is very much about explicit over implicit and a little more on the verbose side versus terse. The current implementation is probably the ideal way to go, but this is here to play with!

Hope you enjoy this! :smiley: