Ruleset updating mechanism to fetch, verify the authenticity of, and apply new ruleset databases

This pull request contains all of the commits I (Zack Mullaly) have made over the course of the Summer of 2014 to build a secure ruleset updating mechanism for my Google Summer of Code 2014 project.
There are still some details (such as a public key) that need to be filled in by whoever now is the primary maintainer of the project, but the feature should be functional once the TODOs are taken care of.
The wrapped variables are constants. When I tried just referring to the regular constant directly from other files like `RulesetUpdater.js`, the constants were undefined.
To make the values available to code with a reference to `HTTPSEverywhere`, the constants can be pointed to by a property of the `HTTPSEverywhere` instance, which could normally be done just by creating `this.MY_CONSTANT = MY_CONSTANT`. However, `this.MY_CONSTANT` is no longer actually a constant itself, but a reference, which can be mutated.
Consider the following code:

    var Person = function(name) { this.name = name; };
    const JOHN = "John"; // Cannot overwrite JOHN by writing JOHN = newValue
    var John = new Person(JOHN);
    console.log(John.name); // prints "John" as we expect
    John.name = "Ashley"; // We *want* this to fail, as with the constant reassignment
    console.log(John.name); // prints "Ashley", because `this.name` is a reference and was overrided

AFAIK, you can't make such a property constant as was done with the JOHN constant. The solution I chose is sort-of borrowed from the OOP idea of encapsulating a value with a getter. It's still possible to overwrite the reference pointing to the getter, but is one stylistic deterrent and one syntactic deterrent to doing so.

* The former is that, it should feel "weird" to developers reassigning a value to a function property, and would require more "effort" to wrap the value in a function, which should make it obvious to developers that this is a no-no.
* The latter is, of course, that if someone accidentally (or naively) wrote something like `HTTPSEverywhere.MIN_REATTEMPT_REQ_INTERVAL = 42;`, the code would fail to run because, everywhere else, `HTTPSEverywhere.MIN_REATTEMPT_REQ_INTERVAL` is being invoked as a function call, and non-function values don't implement the `.call` method.