Implement ScriptableFileSystem.

It's an interface to provide JavaScript API for handling file system.
Now only basic functions are implemented to read and write files.
The API design is found in the Wiki page below.

https://github.com/SollmoStudio/beyond/wiki/Beyond-File-System-API
Add ScriptableFile.

ScriptableFile is a wrapper of Java File class for Rhino. Currently, only
`name`, `path`, `isFile` and `isDirectory` getters are implemented.
Implement `readdir` method for file system API.

`readdir` API reads all files from a provided directory path, and return
a future object of an array of ScriptableFile objects.

The method name and API design follow Node.JS's with a little change in
its result to make it fit in well with Java File API.
Implement ScriptablePath.

ScriptablePath implements a missing `path` module of JavaScript. It has
the same API with one of Node.js.
Move ScriptableRequest and ScriptableResponse to beyond.engine.javascript.lib.http package.
Get rid of actors from GamePlugin.

We don't get much benefits from using actors in GamePlugin implementation.
Using Future is more functional and eaiser to compose.

This patch broke JavaScript timer functions such as setInterval and setTimer.
A follow-up patch will fix this.
Get rid of JavaScript timer functions.

setTimer and setInterval are rarely used. Actually, these functions should not
be used in handler functions because scheduling multiple timers at the same
time has a negative impact on performance. Because the philosophy of Beyond is
to systematically discourage bad programming idioms, I think it's better to get
rid of JavaScript timer functions entirely.
Remove timer function names from BeyondGlobal.

Forgot to remove timer function names in
aec99b65d7a38b9b3fc11cc39adcabee848ee9ee.
Remove JavaScriptConsoleProvider.

JavaScriptConsoleProvider unnecessarily complicates code. Use a unified
implementation in ScriptableConsole and get rid of JavaScriptConsoleProvider.
Extract scriptableClasses an an array.

Don't repeat ScriptableObject.defineClass for each sciptable class. Extract
scripable classes as an array and call ScriptableObject.defineClass for each
class.
Change ScriptableFuture.executeCallback to take variable number of arguments.

This simplfies code because we don't need to create a JSArray when calling
ScriptableFuture.executeCallback.
Don't repeat callbackOnFailure twice.

Move callbackOnFailure to the outer block so that two error cases can share the same
callbackOnFailure. Also move callbackOnSucess for consistency.
Use _ for unused argument name.
Add ScriptableObjectId.
Use ScriptableObjectId instead of ObjectId in JavaScript.

ObjectId will only be used internally.
Make ScriptableDocument return ScriptableObjectId instead of objectId string.
ScriptableCollection.insert method can take an object id.

When passing a JavaScript object that has an object id field, the given object
id will be used as the object id. If the objectId field is null,
ScriptableCollection generates ObjectId.
Apply ObjectId changes to examples.
Implement ScriptableCrypto.

ScriptableCrypto is a wrapper of Play's Crypto object for Rhino,
which provide basic encryption and decryption methods.
Separate OptionParser from ScriptableFileSystem object.

There are many cases where we need to parse optional JSON object.
With the OptionParser class, we can parse the object into a Configuration
instance.