Create new submodule update target to run git submodule update

Resolves #59 at least partially. I have no need for the other submodule commands, but can start adding them if you would like.   

My current project needed to perform submodule updates during the build process, so I added this functionality into grunt-git. I tried to maintain the current style, but did do one thing very differently: Instead of pushing options onto the args array individually, I do so in a loop that loops through an array of ``acceptableOptions``. This way, only options that we are expecting will be passed to the child process, and those that might cause an error (e.g. ``verbose``) will not be. 

**I'm happy to convert it to the more explicit method used elsewhere in this repo if you would prefer.**

All CLI flags for git-submodule-update are supported by this patch, though I suspect that most folks will only use *init* and *recursive*. 

I've also updated the README to include documentation for the new task, and added tests for each option.
Using the underscore string library seems like a more maintainable solution than inserting our own regex into each of the `lib/command_*` files. Underscore.string provides a method called `dasherize` that converts cammelCase strings to dash-separated strings. https://github.com/epeli/underscore.string.

Here is the regex that they use:
```js
return _s.trim(str).replace(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();
```
This will convert ``noFetch`` to ``no-fetch``, but would convert ``NoFetch`` to ``-no-fetch``.

An alternative approach would be to create our own ``lib/util.js`` that contains a method to convert camelCase to dashes. From what I've read, the most efficient algorithm would be the following:
```js
replace(/([a-z\d][A-Z])/g, function (g) { return g[0] + '-' + g[1].toLowerCase() });
```
See http://jsperf.com/js-camelcase for a comparison of regex performance going from a space-delimited string to camelCase. Using a sigle regex with a callback function was about 20% more efficient than chaining two replace methods.