Fast-track @threads when nthreads() == 1

This avoids overhead when threading is disabled, Example benchmark:

```
using BenchmarkTools, Base.Threads

function func(val)
    local sum = 0*(1 .^ val)
    for idx in 1:100
        sum += idx.^val
    end
    return sum
end

function func_threaded(val)
    local sum = 0*(1 .^ val)
    @threads for idx in 1:100
        sum += idx.^val
    end
    return sum
end

@show @benchmark func(2.0)
@show @benchmark func_threaded(2.0)
```

Before change:
```
@benchmark(func(2.0)) = Trial(81.890 ns)
@benchmark(func_threaded(2.0)) = Trial(7.999 μs)
```

After change:
```
@benchmark(func(2.0)) = Trial(81.234 ns)
@benchmark(func_threaded(2.0)) = Trial(3.818 μs)
```

The rest of the overhead is attributed to the `Box` introduced by
#15276

Author: staticfloat

base/threadingconstructs.jl

@@ -25,55 +25,62 @@ function _threadsfor(iter,lbody)
     lidx = iter.args[1]         # index
     range = iter.args[2]
     quote
-        local threadsfor_fun
-        let range = $(esc(range))
-        function threadsfor_fun(onethread=false)
-            r = range # Load into local variable
-            lenr = length(r)
-            # divide loop iterations among threads
-            if onethread
-                tid = 1
-                len, rem = lenr, 0
-            else
-                tid = threadid()
-                len, rem = divrem(lenr, nthreads())
-            end
-            # not enough iterations for all the threads?
-            if len == 0
-                if tid > rem
-                    return
-                end
-                len, rem = 1, 0
+        # Fast-track serial execution for case of nthreads == 1
+        if nthreads() == 1
+            for $(esc(lidx)) in $(esc(range))
+                $(esc(lbody))
             end
-            # compute this thread's iterations
-            f = 1 + ((tid-1) * len)
-            l = f + len - 1
-            # distribute remaining iterations evenly
-            if rem > 0
-                if tid <= rem
-                    f = f + (tid-1)
-                    l = l + tid
+        else
+            local threadsfor_fun
+            let range = $(esc(range))
+            function threadsfor_fun(onethread=false)
+                r = range # Load into local variable
+                lenr = length(r)
+                # divide loop iterations among threads
+                if onethread
+                    tid = 1
+                    len, rem = lenr, 0
                 else
-                    f = f + rem
-                    l = l + rem
+                    tid = threadid()
+                    len, rem = divrem(lenr, nthreads())
+                end
+                # not enough iterations for all the threads?
+                if len == 0
+                    if tid > rem
+                        return
+                    end
+                    len, rem = 1, 0
+                end
+                # compute this thread's iterations
+                f = 1 + ((tid-1) * len)
+                l = f + len - 1
+                # distribute remaining iterations evenly
+                if rem > 0
+                    if tid <= rem
+                        f = f + (tid-1)
+                        l = l + tid
+                    else
+                        f = f + rem
+                        l = l + rem
+                    end
+                end
+                # run this thread's iterations
+                for i = f:l
+                    local $(esc(lidx)) = Base.unsafe_getindex(r,i)
+                    $(esc(lbody))
                 end
             end
-            # run this thread's iterations
-            for i = f:l
-                local $(esc(lidx)) = Base.unsafe_getindex(r,i)
-                $(esc(lbody))
             end
-        end
-        end
-        # Hack to make nested threaded loops kinda work
-        if threadid() != 1 || in_threaded_loop[]
-            # We are in a nested threaded loop
-            Base.invokelatest(threadsfor_fun, true)
-        else
-            in_threaded_loop[] = true
-            # the ccall is not expected to throw
-            ccall(:jl_threading_run, Cvoid, (Any,), threadsfor_fun)
-            in_threaded_loop[] = false
+            # Hack to make nested threaded loops kinda work
+            if threadid() != 1 || in_threaded_loop[]
+                # We are in a nested threaded loop
+                Base.invokelatest(threadsfor_fun, true)
+            else
+                in_threaded_loop[] = true
+                # the ccall is not expected to throw
+                ccall(:jl_threading_run, Cvoid, (Any,), threadsfor_fun)
+                in_threaded_loop[] = false
+            end
         end
         nothing
     end