Optimize zap.Any to allocate less mamory on stack

We have identified an issue where zap.Any can cause performance
degradation due to stack size.

This is apparently cased by the compiler assigning 4.8kb (a zap.Field
per arm of the switch statement) for zap.Any on stack. This can result
in an unnecessary runtime.newstack+runtime.copystack.
A github issue against Go language is pending.

This can be particularly bad if `zap.Any` was to be used in a new
goroutine, since the default goroutine sizes can be as low as 2kb (it can
vary depending on average stack size - see golang/go#18138).

This is an alternative to #1301, @cdvr and me were talking about this,
and he inspired this idea with the closure.

By using a function and a closure we're able to reduce the size and
remove the degradation.
At least on my laptop, this change result in a new performance gain,
as all benchmarks show reduced time.

10 runs.
```
❯ benchstat ~/before2.txt ~/after2.txt
goos: darwin
goarch: arm64
pkg: go.uber.org/zap
                            │ /Users/pawel/before2.txt │       /Users/pawel/after2.txt        │
                            │          sec/op          │    sec/op     vs base                │
Any/str-no-logger-12                      3.344n ±  1%   3.029n ±  1%   -9.40% (p=0.000 n=10)
Any/any-no-logger-12                      13.80n ±  4%   18.67n ±  1%  +35.29% (p=0.000 n=10)
Any/str-with-logger-12                    372.4n ±  3%   363.6n ±  1%   -2.35% (p=0.001 n=10)
Any/any-with-logger-12                    369.2n ±  1%   363.6n ±  1%   -1.52% (p=0.002 n=10)
Any/str-in-go-12                          587.2n ±  2%   587.0n ±  1%        ~ (p=0.617 n=10)
Any/any-in-go-12                          666.5n ±  3%   567.6n ±  1%  -14.85% (p=0.000 n=10)
Any/str-in-go-with-stack-12               448.6n ± 18%   403.4n ± 13%        ~ (p=0.280 n=10)
Any/any-in-go-with-stack-12               564.9n ±  7%   443.2n ±  4%  -21.55% (p=0.000 n=10)
geomean                                   167.8n         160.7n         -4.23%

                            │ /Users/pawel/before2.txt │       /Users/pawel/after2.txt       │
                            │           B/op           │    B/op     vs base                 │
Any/str-no-logger-12                      0.000 ± 0%     0.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-no-logger-12                      0.000 ± 0%     0.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/str-with-logger-12                    64.00 ± 0%     64.00 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-with-logger-12                    64.00 ± 0%     64.00 ± 0%       ~ (p=1.000 n=10) ¹
Any/str-in-go-12                          88.00 ± 0%     88.00 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-in-go-12                          88.00 ± 0%     88.00 ± 0%       ~ (p=1.000 n=10) ¹
Any/str-in-go-with-stack-12               88.00 ± 0%     88.00 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-in-go-with-stack-12               88.00 ± 0%     88.00 ± 0%       ~ (p=1.000 n=10) ¹
geomean                                              ²               +0.00%                ²
¹ all samples are equal
² summaries must be >0 to compute geomean

                            │ /Users/pawel/before2.txt │       /Users/pawel/after2.txt       │
                            │        allocs/op         │ allocs/op   vs base                 │
Any/str-no-logger-12                      0.000 ± 0%     0.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-no-logger-12                      0.000 ± 0%     0.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/str-with-logger-12                    1.000 ± 0%     1.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-with-logger-12                    1.000 ± 0%     1.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/str-in-go-12                          2.000 ± 0%     2.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-in-go-12                          2.000 ± 0%     2.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/str-in-go-with-stack-12               2.000 ± 0%     2.000 ± 0%       ~ (p=1.000 n=10) ¹
Any/any-in-go-with-stack-12               2.000 ± 0%     2.000 ± 0%       ~ (p=1.000 n=10) ¹
geomean
```

On absolute terms:

Before:
```
goos: darwin
goarch: arm64
pkg: go.uber.org/zap
BenchmarkAny/str-with-logger             3154850               387.9 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-with-logger-2           3239221               371.0 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-with-logger-4           3273285               363.8 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-with-logger-8           3251991               372.4 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger             2944020               401.1 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger-2           2984863               368.2 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger-4           3265248               363.0 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger-8           3301592               365.9 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-in-go                    764239              1423 ns/op             140 B/op          2 allocs/op
BenchmarkAny/str-in-go-2                 1510189               753.0 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-4                 3013986               369.1 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-8                 2128927               540.0 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go                    464083              2551 ns/op              88 B/op          2 allocs/op
BenchmarkAny/any-in-go-2                  818104              1347 ns/op              88 B/op          2 allocs/op
BenchmarkAny/any-in-go-4                 1587925               698.9 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-8                 2452558               466.7 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack         767626              1440 ns/op              88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack-2      1534382               771.1 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack-4      2384058               433.4 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack-8      3146942               450.0 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack         434194              2524 ns/op              88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack-2       851312              1304 ns/op              88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack-4      1570944               710.1 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack-8      2546115               604.6 ns/op            88 B/op          2 allocs/op
PASS
ok      go.uber.org/zap 50.238s
```

After:
```
goos: darwin
goarch: arm64
pkg: go.uber.org/zap
BenchmarkAny/str-with-logger             3191725               382.2 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-with-logger-2           3159882               367.4 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-with-logger-4           2998960               373.0 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-with-logger-8           3264657               361.7 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger             3168627               386.2 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger-2           3169394               364.4 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger-4           3271981               368.9 ns/op            64 B/op          1 allocs/op
BenchmarkAny/any-with-logger-8           3293463               362.5 ns/op            64 B/op          1 allocs/op
BenchmarkAny/str-in-go                    793905              1388 ns/op             143 B/op          2 allocs/op
BenchmarkAny/str-in-go-2                 1724048               748.4 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-4                 2536380               444.9 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-8                 2177941               586.1 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go                    890155              1237 ns/op              88 B/op          2 allocs/op
BenchmarkAny/any-in-go-2                 1836302               719.1 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-4                 3671503               322.2 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-8                 2257405               540.8 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack         811408              1457 ns/op              88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack-2      1384990               729.6 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack-4      3228151               381.8 ns/op            88 B/op          2 allocs/op
BenchmarkAny/str-in-go-with-stack-8      2678596               450.8 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack         821092              1386 ns/op              88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack-2      1747638               662.3 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack-4      3747934               341.9 ns/op            88 B/op          2 allocs/op
BenchmarkAny/any-in-go-with-stack-8      2678191               463.6 ns/op            88 B/op          2 allocs/op
PASS
ok      go.uber.org/zap 53.238s
```

field.go

@@ -418,132 +418,263 @@ func Inline(val zapcore.ObjectMarshaler) Field {
 // them. To minimize surprises, []byte values are treated as binary blobs, byte
 // values are treated as uint8, and runes are always treated as integers.
 func Any(key string, value interface{}) Field {
+	// To work around go compiler assigning unreasonably large space on stack
+	// (4kb, one `Field` per arm of the switch statement) which can trigger
+	// performance degradation if `Any` is used in a brand new goroutine.
+	var f func() Field
 	switch val := value.(type) {
 	case zapcore.ObjectMarshaler:
-		return Object(key, val)
+		f = func() Field {
+			return Object(key, val)
+		}
 	case zapcore.ArrayMarshaler:
-		return Array(key, val)
+		f = func() Field {
+			return Array(key, val)
+		}
 	case bool:
-		return Bool(key, val)
+		f = func() Field {
+			return Bool(key, val)
+		}
 	case *bool:
-		return Boolp(key, val)
+		f = func() Field {
+			return Boolp(key, val)
+		}
 	case []bool:
-		return Bools(key, val)
+		f = func() Field {
+			return Bools(key, val)
+		}
 	case complex128:
-		return Complex128(key, val)
+		f = func() Field {
+			return Complex128(key, val)
+		}
 	case *complex128:
-		return Complex128p(key, val)
+		f = func() Field {
+			return Complex128p(key, val)
+		}
 	case []complex128:
-		return Complex128s(key, val)
+		f = func() Field {
+			return Complex128s(key, val)
+		}
 	case complex64:
-		return Complex64(key, val)
+		f = func() Field {
+			return Complex64(key, val)
+		}
 	case *complex64:
-		return Complex64p(key, val)
+		f = func() Field {
+			return Complex64p(key, val)
+		}
 	case []complex64:
-		return Complex64s(key, val)
+		f = func() Field {
+			return Complex64s(key, val)
+		}
 	case float64:
-		return Float64(key, val)
+		f = func() Field {
+			return Float64(key, val)
+		}
 	case *float64:
-		return Float64p(key, val)
+		f = func() Field {
+			return Float64p(key, val)
+		}
 	case []float64:
-		return Float64s(key, val)
+		f = func() Field {
+			return Float64s(key, val)
+		}
 	case float32:
-		return Float32(key, val)
+		f = func() Field {
+			return Float32(key, val)
+		}
 	case *float32:
-		return Float32p(key, val)
+		f = func() Field {
+			return Float32p(key, val)
+		}
 	case []float32:
-		return Float32s(key, val)
+		f = func() Field {
+			return Float32s(key, val)
+		}
 	case int:
-		return Int(key, val)
+		f = func() Field {
+			return Int(key, val)
+		}
 	case *int:
-		return Intp(key, val)
+		f = func() Field {
+			return Intp(key, val)
+		}
 	case []int:
-		return Ints(key, val)
+		f = func() Field {
+			return Ints(key, val)
+		}
 	case int64:
-		return Int64(key, val)
+		f = func() Field {
+			return Int64(key, val)
+		}
 	case *int64:
-		return Int64p(key, val)
+		f = func() Field {
+			return Int64p(key, val)
+		}
 	case []int64:
-		return Int64s(key, val)
+		f = func() Field {
+			return Int64s(key, val)
+		}
 	case int32:
-		return Int32(key, val)
+		f = func() Field {
+			return Int32(key, val)
+		}
 	case *int32:
-		return Int32p(key, val)
+		f = func() Field {
+			return Int32p(key, val)
+		}
 	case []int32:
-		return Int32s(key, val)
+		f = func() Field {
+			return Int32s(key, val)
+		}
 	case int16:
-		return Int16(key, val)
+		f = func() Field {
+			return Int16(key, val)
+		}
 	case *int16:
-		return Int16p(key, val)
+		f = func() Field {
+			return Int16p(key, val)
+		}
 	case []int16:
-		return Int16s(key, val)
+		f = func() Field {
+			return Int16s(key, val)
+		}
 	case int8:
-		return Int8(key, val)
+		f = func() Field {
+			return Int8(key, val)
+		}
 	case *int8:
-		return Int8p(key, val)
+		f = func() Field {
+			return Int8p(key, val)
+		}
 	case []int8:
-		return Int8s(key, val)
+		f = func() Field {
+			return Int8s(key, val)
+		}
 	case string:
-		return String(key, val)
+		f = func() Field {
+			return String(key, val)
+		}
 	case *string:
-		return Stringp(key, val)
+		f = func() Field {
+			return Stringp(key, val)
+		}
 	case []string:
-		return Strings(key, val)
+		f = func() Field {
+			return Strings(key, val)
+		}
 	case uint:
-		return Uint(key, val)
+		f = func() Field {
+			return Uint(key, val)
+		}
 	case *uint:
-		return Uintp(key, val)
+		f = func() Field {
+			return Uintp(key, val)
+		}
 	case []uint:
-		return Uints(key, val)
+		f = func() Field {
+			return Uints(key, val)
+		}
 	case uint64:
-		return Uint64(key, val)
+		f = func() Field {
+			return Uint64(key, val)
+		}
 	case *uint64:
-		return Uint64p(key, val)
+		f = func() Field {
+			return Uint64p(key, val)
+		}
 	case []uint64:
-		return Uint64s(key, val)
+		f = func() Field {
+			return Uint64s(key, val)
+		}
 	case uint32:
-		return Uint32(key, val)
+		f = func() Field {
+			return Uint32(key, val)
+		}
 	case *uint32:
-		return Uint32p(key, val)
+		f = func() Field {
+			return Uint32p(key, val)
+		}
 	case []uint32:
-		return Uint32s(key, val)
+		f = func() Field {
+			return Uint32s(key, val)
+		}
 	case uint16:
-		return Uint16(key, val)
+		f = func() Field {
+			return Uint16(key, val)
+		}
 	case *uint16:
-		return Uint16p(key, val)
+		f = func() Field {
+			return Uint16p(key, val)
+		}
 	case []uint16:
-		return Uint16s(key, val)
+		f = func() Field {
+			return Uint16s(key, val)
+		}
 	case uint8:
-		return Uint8(key, val)
+		f = func() Field {
+			return Uint8(key, val)
+		}
 	case *uint8:
-		return Uint8p(key, val)
+		f = func() Field {
+			return Uint8p(key, val)
+		}
 	case []byte:
-		return Binary(key, val)
+		f = func() Field {
+			return Binary(key, val)
+		}
 	case uintptr:
-		return Uintptr(key, val)
+		f = func() Field {
+			return Uintptr(key, val)
+		}
 	case *uintptr:
-		return Uintptrp(key, val)
+		f = func() Field {
+			return Uintptrp(key, val)
+		}
 	case []uintptr:
-		return Uintptrs(key, val)
+		f = func() Field {
+			return Uintptrs(key, val)
+		}
 	case time.Time:
-		return Time(key, val)
+		f = func() Field {
+			return Time(key, val)
+		}
 	case *time.Time:
-		return Timep(key, val)
+		f = func() Field {
+			return Timep(key, val)
+		}
 	case []time.Time:
-		return Times(key, val)
+		f = func() Field {
+			return Times(key, val)
+		}
 	case time.Duration:
-		return Duration(key, val)
+		f = func() Field {
+			return Duration(key, val)
+		}
 	case *time.Duration:
-		return Durationp(key, val)
+		f = func() Field {
+			return Durationp(key, val)
+		}
 	case []time.Duration:
-		return Durations(key, val)
+		f = func() Field {
+			return Durations(key, val)
+		}
 	case error:
-		return NamedError(key, val)
+		f = func() Field {
+			return NamedError(key, val)
+		}
 	case []error:
-		return Errors(key, val)
+		f = func() Field {
+			return Errors(key, val)
+		}
 	case fmt.Stringer:
-		return Stringer(key, val)
+		f = func() Field {
+			return Stringer(key, val)
+		}
 	default:
-		return Reflect(key, val)
+		f = func() Field {
+			return Reflect(key, val)
+		}
 	}
+	return f()
 }