repl: Catch syntax errors better

Replace the growing list of 'isSyntaxError' whackamole conditions with a
smarter approach.  This creates a vm Script object *first*, which will
parse the code and raise a SyntaxError right away.

We still do need the test function, but only because strict mode syntax
errors are not recoverable, and should be raised right away.  Really, we
should probably *only* continue on "unexpected end of input" SyntaxErrors.

Also fixes a very difficult-to-test nit where the '...' indentation is
not properly cleared when you ^C out of a syntax error.

Closes #6093
repl: treat "Assignment to const" as syntax error

Adding a new `repl-harmony` test file here because adding the
`--use_strict --harmony` flags on the main repl test file was causing
lots of unrelated failures, due to global variable assignments and
things like that. This new test file is based off of the original
repl.js test file, but has a lot of the tests stripped out. A test case
for this commit is included though.

Fixes #6132.
repl: Simplify paren wrap, continuation-detection

This simplifies the logic that was in isSyntaxError, as well as the
choice to wrap command input in parens to coerce to an expression
statement.

1. Rather than a growing blacklist of allowed-to-throw syntax errors,
just sniff for the one we really care about ("Unexpected end of input")
and let all the others pass through.

2. Wrapping {a:1} in parens makes sense, because blocks and line labels
are silly and confusing and should not be in JavaScript at all.
However, wrapping functions and other types of programs in parens is
weird and required yet *more* hacking to work around.  By only wrapping
statements that start with { and end with }, we can handle the confusing
use-case, without having to then do extra work for functions and other
cases.

This also fixes the repl wart where `console.log)(` works in the repl,
but only by virtue of the fact that it's wrapped in parens first, as
well as potential side effects of double-running the commands, such as:

    > x = 1
    1
    > eval('x++; throw new SyntaxError("e")')
    ... ^C
    > x
    3
stream: make setEncoding chainable
stream: return this from pause()/resume()
http: Only send connection:keep-alive if necessary

In cases where the Agent has maxSockets=Infinity, and
keepAlive=false, there's no case where we won't immediately close the
connection after the response is completed.

Since we're going to close it anyway, send a `connection:close` header
rather than a `connection:keep-alive` header.  Still send the
`connection:keep-alive` if the agent will actually reuse the socket,
however.

Closes #5838
multi-context wip
multi-context startup wip
multi-context security token wip
address MakeCallback() context FIXMEs
fix two debugger tests, use default loop
node: don't share state with in_tick/last_threw

There was no need to share state between C++ and JS for these two
values. So they have been moved to their respective locations. This will
help performance only a tiny bit, but it does help code complexity much
more.
test: add asyncListener tests

These tests should cover all basic uses of the asyncListener API.
node: add basic asyncListener skeleton

The implementation necessary before other parts of Node can start
calling the asyncListener.
src: add preliminary support for asyncListener

AsyncListener support has been added to ReqWrap, Timers, Events and
nextTick. The listeners will not yet propagate with asynchronous
callbacks called within other callbacks.
src: support for catching nested async callbacks

Async listeners should now propagate through nested callbacks.

Note: This is NOT performance ready. It's simply getting the
functionality to work.
src: fix two syntax errors

First was an improper comparison with bool to int. Second was to "throw
error" instead of "throw new Error".
node: add simple performance enhancement

Until the first asyncListener is loaded, they will remain inactive. This
is largely advantageous to C++, as it is very expensive to check named
Object properties.

This is only a first step. In the end there should be a faster way to
check for these properties and the kActive should be able to toggle when
there are no more possible active listeners in the pipe. Though that
would require knowledge of all listeners attached to callbacks in the
wild.
WIP: initially add support for AsyncFlags

This is a quicker way to check if the asynchronous request has listeners
waiting on the object to be processed by MakeCallback.
events: remove async listener support

An EventEmitter on its own won't break the call stack, so there's no
need to fire asyncListener when a callback is queued.