Debugger improvements 3 (#852)

* Prevent recursive calls to DebugHandler Break/Step

* Reinstated Debugger StepMode tests for accessors

They are now relevant (and pass), after the improvements to call stack.
Fixed a mistake in previously skipped StepsOverSetAccessor test

* Removed DebugHandler call stack management - reuse Engine's call stack

DebugInformation now includes public representation of internal Engine callstack, rather than just list of Callable names

* Proper locations for debug call stack

* Fixed EngineTests broken by the now proper call stack size

* Early work on better debugger scopes

* Better ScopeTests, testing all scopes for non-existence of binding.

* Support for step/break on function return

Slight refactor of DebugInformation

* Scope chain resolution closer to Chromium

* Support for inspecting all frames in DebugCallStack

Lazily populated scope chains
New DebugInformation more closely aligned with devtools protocol
Currently this causes regression (and failing tests) due to lack of access to the ExecutionContext through JintCallStack

* Added CallingExecutionContext to JintCallStack

In order to allow generation of scope chains for all call frames in the call stack (for devtools), we need access to the current lexical environment all the way down the call stack.
Fixed tests checking in Block scope for const/let at the top level of functions - they're now collapsed to Local scope, mirroring the Chromium approach.

* Clean-up, tests and documentation for new Debug API

Scope Chain tests
More CallStack tests
Return point stepping test
Simplified function naming tests for CallStack (using TestHelpers)

* Simple review fixes

* New DebugScopes API

Dictionary access replaced with Bindings and BindingNames lists on DebugScope
Lazy binding value evaluation for scopes
Removed this from scope bindings - can be found with CallFrame.This
Function top-level block and function scopes are no longer combined - can be combined by caller using new IsTopLevel property on top-level block scopes.

* Simpler (and more efficient) scope bindings API

* Updated tests for new DebugScope API

* All debugger related API moved into DebugHandler

Removed LINQ evaluation of breakpoints.
Renamed BreakPoint properties and parameters to reflect the terminology of the rest of Jint (and Esprima)

* Moved GetThisEnvironment to ExecutionContext for reuse in CallFrame.This

Jint.Tests/Runtime/Debugger/BreakPointTests.cs

@@ -18,15 +18,15 @@ public void BreakPointBreaksAtPosition()
             var engine = new Engine(options => options.DebugMode());
 
             bool didBreak = false;
-            engine.Break += (sender, info) =>
+            engine.DebugHandler.Break += (sender, info) =>
             {
                 Assert.Equal(4, info.CurrentStatement.Location.Start.Line);
                 Assert.Equal(5, info.CurrentStatement.Location.Start.Column);
                 didBreak = true;
                 return StepMode.None;
             };
 
-            engine.BreakPoints.Add(new BreakPoint(4, 5));
+            engine.DebugHandler.BreakPoints.Add(new BreakPoint(4, 5));
             engine.Execute(script);
             Assert.True(didBreak);
         }
@@ -50,10 +50,10 @@ public void BreakPointBreaksInCorrectSource()
 
             var engine = new Engine(options => { options.DebugMode(); });
 
-            engine.BreakPoints.Add(new BreakPoint("script2", 3, 0));
+            engine.DebugHandler.BreakPoints.Add(new BreakPoint("script2", 3, 0));
 
             bool didBreak = false;
-            engine.Break += (sender, info) =>
+            engine.DebugHandler.Break += (sender, info) =>
             {
                 Assert.Equal("script2", info.CurrentStatement.Location.Source);
                 Assert.Equal(3, info.CurrentStatement.Location.Start.Line);
@@ -88,7 +88,7 @@ public void DebuggerStatementTriggersBreak()
                 .DebuggerStatementHandling(DebuggerStatementHandling.Script));
 
             bool didBreak = false;
-            engine.Break += (sender, info) =>
+            engine.DebugHandler.Break += (sender, info) =>
             {
                 didBreak = true;
                 return StepMode.None;
@@ -110,10 +110,10 @@ public void DebuggerStatementAndBreakpointTriggerSingleBreak()
                 .DebugMode()
                 .DebuggerStatementHandling(DebuggerStatementHandling.Script));
 
-            engine.BreakPoints.Add(new BreakPoint(2, 0));
+            engine.DebugHandler.BreakPoints.Add(new BreakPoint(2, 0));
 
             int breakTriggered = 0;
-            engine.Break += (sender, info) =>
+            engine.DebugHandler.Break += (sender, info) =>
             {
                 breakTriggered++;
                 return StepMode.None;
@@ -138,11 +138,11 @@ public void BreakpointOverridesStepOut()
 
             var engine = new Engine(options => options.DebugMode());
 
-            engine.BreakPoints.Add(new BreakPoint(4, 0));
-            engine.BreakPoints.Add(new BreakPoint(6, 0));
+            engine.DebugHandler.BreakPoints.Add(new BreakPoint(4, 0));
+            engine.DebugHandler.BreakPoints.Add(new BreakPoint(6, 0));
 
             int step = 0;
-            engine.Break += (sender, info) =>
+            engine.DebugHandler.Break += (sender, info) =>
             {
                 step++;
                 switch (step)