use withCallingHandlers() so that users can do error handling like recover()

If I understand you guys correctly, here is probably what we want to do. Now we can `options(shiny.error = recover)` if we want to see the call stacks when errors occur, and examine the frames, although the number of frames can be quite large (more than 40 before the relevant frames are reached).

I have tried my best to insert the new `shinyCallingHandlers()` to the places where I think are relevant. There are a couple more `try()` calls without it. I guess they do not need it, but @jcheng5 certainly knows more than I do.

A sample stack is like this:

```
Enter a frame number, or 0 to exit   

 1: runApp()
 2: tryCatch(shinyCallingHandlers(while (!.globals$stopped) {
    serviceApp()
  
 3: tryCatchList(expr, classes, parentenv, handlers)
 4: shinyCallingHandlers(while (!.globals$stopped) {
    serviceApp()
    Sys.sle
 5: withCallingHandlers(expr, error = function(e) {
    handle <- getOption("shi
 6: serviceApp()
 7: service(timeout)
 8: run(timeoutMs)
 9: tryCatch(evalq((function (handle, binary, message) 
{
    for (handler in .ws
10: tryCatchList(expr, classes, parentenv, handlers)
11: tryCatchOne(expr, names, parentenv, handlers[[1]])
12: doTryCatch(return(expr), name, parentenv, handler)
13: evalq((function (handle, binary, message) 
{
    for (handler in .wsconns[[as
14: eval(substitute(expr), envir, enclos)
15: (function (handle, binary, message) 
{
    for (handler in .wsconns[[as.chara
16: try(handler(binary, message))
17: tryCatch(expr, error = function(e) {
    call <- conditionCall(e)
    if (!is
18: tryCatchList(expr, classes, parentenv, handlers)
19: tryCatchOne(expr, names, parentenv, handlers[[1]])
20: doTryCatch(return(expr), name, parentenv, handler)
21: handler(binary, message)
22: flushReact()
23: .getReactiveEnvironment()$flush()
24: ctx$executeFlushCallbacks()
25: lapply(.flushCallbacks, function(func) {
    withCallingHandlers({
        fu
26: FUN(X[[1]], ...)
27: withCallingHandlers({
    func()
}, warning = function(e) {
}, error = functio
28: func()
29: run()
30: ctx$run(.func)
31: env$runWith(.self, func)
32: func()
33: try(shinyCallingHandlers(func()), silent = FALSE)
34: tryCatch(expr, error = function(e) {
    call <- conditionCall(e)
    if (!is
35: tryCatchList(expr, classes, parentenv, handlers)
36: tryCatchOne(expr, names, parentenv, handlers[[1]])
37: doTryCatch(return(expr), name, parentenv, handler)
38: shinyCallingHandlers(func())
39: withCallingHandlers(expr, error = function(e) {
    handle <- getOption("shi
40: func()
41: func()
42: server.R#11: f()
43: server.R#9: .handleSimpleError(function (e) 
{
    handle <- getOption("shiny
44: h(simpleError(msg, call))
```

#249 #217