A (client side) `require` could instead use `ripple` (for consistency).

This is not a bug, just an attempt to keep a consistent way of requiring
modules in the client (browser based) code.
Need to update OpenLayers to v2.12.

https://github.com/openlayers/openlayers/blob/master/notes/2.12.md

There seems to be an issue with the current version of
OpenLayers that, when it was wrapped in an auto-invoked
function, it would throw a unexpected exception and
ultimately cause Ripple to stop working.

Note: The auto invoked function will be in an upcoming commit.
OpenLayers (incorrectly) attempts to auto load a non-existent CSS file.

The CSS file is not needed for what OpenLayers is being used for
(and never was). Passing in a null theme value causes the request
(to load the file) to never occur, vs logging failure to console.
The (hacky) init of the (geo plugin) map needs to be fixed (properly).

With the update to OpenLayers 2.12, it caused a bug that was originally
identified when the feature was fist submitted, but was fixed in a
(rather hacky) way. I'm not sure if it is a fix or some code cleanup in
the new release of OpenLayers, but it is now happening consistently.

The bug is when you enable Ripple with the Geo Location panel closed,
then open it. An exception will be thrown:

    Uncaught TypeError: Cannot read property 'w' of null

However, if you load Ripple and the Geo Location panel is already open,
the map initializes as expected.

This fixes the issue in the way it should of been fixed. As a result,
the visibility check hack can be removed, as well.
A unit test was not mocking the `ripple` (require) shortcut method.

Instead, it was still mocking the `require` method which, if it
were to be out of scope, would throw an exception in the test.

Note: This is observed in the browser test runner.
Ripple's (compiled) client file should expose select objects on window.

Currently, any objects (or functions) in Ripple's client code, which
includes any thirdparty code, when injected into a web page, would all
be exposed in window, so you would have things like `require` and
`define` in the "global" namespace, which can cause namespace clashes
with an application's code (as well as the other way around).

Now, the _only_ thing that (should) be exposed is the `ripple`
function (which also has a define method on it), which can be used to
require and define modules (ex: via the JS console).

The main reason this was done was to possibly fix this:

https://github.com/blackberry/Ripple-UI/issues/354

However, it is good practise, in general, and should of been done some
time ago, if not, during the compression (build) step.

Note: This required that OpenLayers be updated to v2.12.

Note: A option to not wrap in an auto-invoked function was added so the
browser test runner tests would be able to access thirdparty code (to
mock, etc). This also meant all the manual references could be removed
in favour of the ones in Ripple's client file.
Almond can be replaced with a more lightweight implementation.

Also, it is confusing (and more complex) to support both a `ripple`
and a `require` method (for `lib/client` files), so the more
lightweight implementation (of `require`) was renamed to (only)
expose a method called `ripple`.

i.e. If you are in `lib/client`, you _must_ use `ripple` (and
`ripple.define).

Note: Since we use parts of Cordova (and not just with the addition of
this piece of code), the LICENSE file was updated to mention this.
The Chrome Extension iframe injection should check for `ripple`.

Previously, it was checking for `window.top.require`, then using
`window.top.ripple` to require modules. This was an oversight done in a
previous refactor that did not break things until all the code in
Ripple's client file (except `window.ripple`) was closured and hidden
from the global scope.
Throw a helpful error when registering for an unsupported (BB10) event.

Take this example:

    blackberry.event.addEventListener("onaccesschanged", function () {})

If an unsupported event name is registered for, it would throw an error
like this:

    Uncaught TypeError: Cannot read property 'callbacks' of undefined.

Now, it will throw a `new Error(..)` with a message like this:

    Uncaught Error: Cannot register a handler for the onaccesschanged
    event, because it does not seem to be supported.

This commit is related (but does not fix) to this GitHub issue:

    https://github.com/blackberry/Ripple-UI/issues/629
`watchPosition` shouldn't invoke error when passed undefined options.

The 3rd argument (geolocationOptions) in the W3C geolocation module
is optional. Currently, if it was omitted, it would cause the error
callback to be invoked, which is incorrect.

This fixes:

https://github.com/blackberry/Ripple-UI/issues/645
`clearWatch` should not throw an exception if given invalid id.

The W3C geolocation module's clearWatch method should silently execute
if it is given an invalid (i.e. non-registered) watch id.

See: http://dev.w3.org/geo/api/spec-source.html#clear-watch

This also touches on this GitHub issue:

https://github.com/blackberry/Ripple-UI/issues/645