Improve marshal speed (#47)

* Add fast case for non-escaped inputs.
* Add specialized float printing.

```
benchmark                                             old ns/op     new ns/op     delta
BenchmarkIter_MarshalJSONBuffer/apache_builds-32      287323        148202        -48.42%
BenchmarkIter_MarshalJSONBuffer/canada-32             13529136      10290900      -23.94%
BenchmarkIter_MarshalJSONBuffer/citm_catalog-32       1727759       1231152       -28.74%
BenchmarkIter_MarshalJSONBuffer/github_events-32      147846        72801         -50.76%
BenchmarkIter_MarshalJSONBuffer/gsoc-2018-32          7302709       3186714       -56.36%
BenchmarkIter_MarshalJSONBuffer/instruments-32        405617        249186        -38.57%
BenchmarkIter_MarshalJSONBuffer/numbers-32            1114819       803988        -27.88%
BenchmarkIter_MarshalJSONBuffer/marine_ik-32          15554551      13492569      -13.26%
BenchmarkIter_MarshalJSONBuffer/mesh-32               4519934       3556764       -21.31%
BenchmarkIter_MarshalJSONBuffer/mesh.pretty-32        4542054       3540605       -22.05%
BenchmarkIter_MarshalJSONBuffer/twitterescaped-32     1361729       653521        -52.01%
BenchmarkIter_MarshalJSONBuffer/twitter-32            1361365       635662        -53.31%
BenchmarkIter_MarshalJSONBuffer/random-32             1593711       927722        -41.79%
BenchmarkIter_MarshalJSONBuffer/update-center-32      1599886       778478        -51.34%

benchmark                                             old MB/s     new MB/s     speedup
BenchmarkIter_MarshalJSONBuffer/apache_builds-32      329.43       638.68       1.94x
BenchmarkIter_MarshalJSONBuffer/canada-32             154.50       203.11       1.31x
BenchmarkIter_MarshalJSONBuffer/citm_catalog-32       289.57       406.37       1.40x
BenchmarkIter_MarshalJSONBuffer/github_events-32      360.71       732.54       2.03x
BenchmarkIter_MarshalJSONBuffer/gsoc-2018-32          420.40       963.39       2.29x
BenchmarkIter_MarshalJSONBuffer/instruments-32        267.03       434.67       1.63x
BenchmarkIter_MarshalJSONBuffer/numbers-32            134.66       186.72       1.39x
BenchmarkIter_MarshalJSONBuffer/marine_ik-32          117.59       135.56       1.15x
BenchmarkIter_MarshalJSONBuffer/mesh-32               142.19       180.70       1.27x
BenchmarkIter_MarshalJSONBuffer/mesh.pretty-32        141.50       181.52       1.28x
BenchmarkIter_MarshalJSONBuffer/twitterescaped-32     342.88       714.45       2.08x
BenchmarkIter_MarshalJSONBuffer/twitter-32            342.97       734.52       2.14x
BenchmarkIter_MarshalJSONBuffer/random-32             289.55       497.42       1.72x
BenchmarkIter_MarshalJSONBuffer/update-center-32      333.12       684.62       2.06x
```

Author: klauspost

appendfloat_f.go

@@ -0,0 +1,98 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Modified for 'f' format with inlined variables.
+
+package simdjson
+
+import "math"
+
+func appendFloatF(dst []byte, val float64) []byte {
+	var prec int
+	var bits uint64
+	bits = math.Float64bits(val)
+	//var float64info = floatInfo{mantbits: 52, expbits: 11, bias: -1023}
+	const mantbits = 52
+	const expbits = 11
+	const bias = -1023
+	//flt = &float64info
+
+	neg := bits>>(expbits+mantbits) != 0
+	exp := int(bits>>mantbits) & (1<<expbits - 1)
+	mant := bits & (uint64(1)<<mantbits - 1)
+
+	switch exp {
+	case 0:
+		// denormalized
+		exp++
+
+	default:
+		// add implicit top bit
+		mant |= uint64(1) << mantbits
+	}
+	exp += bias
+
+	var digs decimalSlice
+	// Use Ryu algorithm.
+	var buf [32]byte
+	digs.d = buf[:]
+	ryuFtoaShortest(&digs, mant, exp-mantbits)
+	// Precision for shortest representation mode.
+
+	prec = max(digs.nd-digs.dp, 0)
+	return fmtF(dst, neg, digs, prec)
+}
+
+type decimalSlice struct {
+	d      []byte
+	nd, dp int
+	neg    bool
+}
+
+// %f: -ddddddd.ddddd
+func fmtF(dst []byte, neg bool, d decimalSlice, prec int) []byte {
+	// sign
+	if neg {
+		dst = append(dst, '-')
+	}
+
+	// integer, padded with zeros as needed.
+	if d.dp > 0 {
+		m := min(d.nd, d.dp)
+		dst = append(dst, d.d[:m]...)
+		for ; m < d.dp; m++ {
+			dst = append(dst, '0')
+		}
+	} else {
+		dst = append(dst, '0')
+	}
+
+	// fraction
+	if prec > 0 {
+		dst = append(dst, '.')
+		for i := 0; i < prec; i++ {
+			ch := byte('0')
+			if j := d.dp + i; 0 <= j && j < d.nd {
+				ch = d.d[j]
+			}
+			dst = append(dst, ch)
+		}
+	}
+
+	return dst
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}