This adds a way to call native javascript methods from ruby using
valid ruby syntax, so it will work with existing tooling.

This will only break working ruby code that defines a method named
JS that will accept no arguments, and uses that method in a method
chain.

This makes it much easier to use javascript objects inside ruby
code without wrapping them using Native(), and provides a work
around for edge cases where Native(obj) returns obj, such as
when using strings.  This syntax will handle many cases where
you currently need to drop down to raw javascript using backticks.

This adds js_prefix attributes to the lexer and parser, and
uses a :js_prefix compiler option.  It is supported in
bin/opal using the --js_prefix flag.

The lexer currently supports custom prefixes, in case people
are already using a method named JS.  This isn't currently
supported by bin/opal, but can be enabled manually by using
a string as the :js_prefix compiler option value.

This reverts commit ec105e5.

To call javascript functions with no arguments , you now need to
use parentheses (e.g. foo.JS.func()).

This causes 8 reduce/reduce conflicts in the grammar, but I haven't
yet figured out how to eliminate that.

This changes the grammar to support calling javascript methods
without parentheses:

  a.JS.b 1, 2

and with blocks:

  a.JS.b { |v| ...}
  a.JS.b(1) { |v| ...}
  a.JS.b do |v| ... end
  a.JS.b(1) do |v| ... end
  a.JS.b 1 do |v| ... end

This changes the previous behavior for method calls without
parentheses.  Previously, they returned the javascript property
instead of doing a method call.  Now using .JS. always does a
method call.  If you want to return a property, use a.JS[:b]
Similarly, you can no longer set properties via a.JS.b = 1,
you now need to use a.JS[:b] = 1.

This eliminates the reduce/reduce conflicts that the addition
of property setters added.  One thing this doesn't support is
syntax like:

  foo.JS[:b] += 1

I had to specifically add support to the grammar to handle that
syntax in order to eliminate the reduce/reduce conflicts, but
now it just raises an error.  I think raising an error is the
correct behavior in this case.  This would desugar to:

  foo.JS[:b] = foo.JS[:b].+(1)

which would only make sense if foo was a javascript object with
a property b that was a ruby object.  That seems fairly unlikely
in practice, but support could probably be added to handle that
case.  I think adding such support could confuse people, since
they may expect it to operate the same as:

  `foo["b"] += 1`

To support calling javascript methods with blocks, I had to copy
the implementation of CallNode#default_compile to JsCallNode,
and then modify it.  It may be possible to refactor
CallNode#default_compile to split it up into more methods, and
reduce the duplication, but I'm not sure it is worth it.

Since the javascript property setter syntax was limited to
recv.JS['prop'] = , this code can be removed.

Support recv.JS.js_method syntax for calling javascript methods