Detection of existent codestyle

As I'm a bad programmer, so please look at this code with a serious face and either point me all the bad things I've done (so I could go and fix them), or treat it as a proof-of-concept-prototype, which you can take and rewrite from scratch :)

What is done now: there is a flag `._detect` that tells processing functions not to rewrite the codestyle, but instead only read and populate the `._detected` object. Then there is a `.detect()` function that sets this flag and populates the `._detected` objects with the properties we want to detect. In future it would take an array of the options we want to detect. And finally, if the flag is set, the processing functions should return the object with detected options. Right now only `.processString` is covered, others would be done later. And then every option can have its `detect` method, that should return the found codestyle for the node. I've tried to reuse the existent code as much as I could, but if there any things that could be done in a more optimal way — tell me (or send a PR for my PR's branch and I'll merge it into it).

## Major features:

- [x] Detection — CSSComb.js should have a way to parse a CSS file and return an object with detected options.

- <del>Averaging — CSSComb.js should have a way to use its detection to normalize existent files. It should take files, detect the properties in them and then use the detected code style to normalize all the stuff. Question: should we have two possible options for normalize feature — a) we should either normalize files independently, so each file's code style would be normalized with itself, or b) we could sum all the codestyles in the given files, so it would be averaged to the whole input.</del> — on the second thought, I can't really see the use-cases for this.

- <del>Detect for multiple files/paths.</del> — I'll move it to another issue, as it could be done later.

- [x] Read settings from `.css` file — CSSComb.js should take `.css` file as a `-c, --config [path]`, in that case it should detect the used code style there and use it as a template. And/or, instead of using `.css` file, we could have a `template` option in `.csscomb.json`, which would point to this template file, this way we could then merge the detected options with the ones we have in the `.csscomb.json`.

- [x] Readme for all the stuff above :) [done](https://github.com/kizu/csscomb.js/tree/detector#through-css-template)

## Options to do:

- [x] `remove-empty-rulesets`
- [x] `always-semicolon`
- [x] `color-case`
- [x] `color-shorthand`
- [x] `element-case`
- [x] `leading-zero`
- [x] `strip-spaces`
- [x] `eof-newline`
- [x] `stick-brace`
- [x] `colon-space`
- [x] `combinator-space`
- [x] `rule-indent`
- [x] `block-indent`
- [x] `unitless-zero`
- <del>`sort-order` — *this shouldn't be autodetected, at least for now*</del>