Reuse AST storage between top-level expressions

```
Comparing:
	old: v2-wip/1da2fc7 (2021-03-25 20:38:05 -0400 -0400)
	run: v2-wip/3f23ab9 (2021-03-25 22:35:06 -0400 -0400)
-----------------------------------------------------------
name                  old time/op    new time/op    delta
UnmarshalSimple/v2-8     700ns ± 3%     705ns ± 2%     ~     (p=0.690 n=5+5)
UnmarshalSimple/v1-8    3.85µs ± 1%    4.02µs ± 4%   +4.19%  (p=0.032 n=5+5)
UnmarshalSimple/bs-8    2.34µs ± 2%    2.38µs ± 3%     ~     (p=0.310 n=5+5)
ReferenceFile/v2-8      32.2µs ±13%    23.9µs ± 1%  -25.79%  (p=0.008 n=5+5)
ReferenceFile/v1-8       270µs ± 2%     264µs ± 2%     ~     (p=0.095 n=5+5)
ReferenceFile/bs-8       291µs ± 0%     294µs ± 0%   +0.88%  (p=0.008 n=5+5)

name                  old alloc/op   new alloc/op   delta
ReferenceFile/v2-8      37.1kB ± 0%     6.7kB ± 0%  -81.91%  (p=0.008 n=5+5)
ReferenceFile/v1-8       131kB ± 0%     131kB ± 0%     ~     (p=0.444 n=5+5)
ReferenceFile/bs-8      80.8kB ± 0%    80.8kB ± 0%     ~     (p=0.571 n=5+5)

name                  old allocs/op  new allocs/op  delta
ReferenceFile/v2-8         152 ± 0%       148 ± 0%   -2.63%  (p=0.008 n=5+5)
ReferenceFile/v1-8       2.65k ± 0%     2.65k ± 0%     ~     (all equal)
ReferenceFile/bs-8       1.73k ± 0%     1.73k ± 0%     ~     (all equal)

~/s/g/p/g/benchmark$ go test -bench=.
goos: linux
goarch: amd64
pkg: github.com/pelletier/go-toml/v2/benchmark
cpu: Intel(R) Core(TM) i7-7700 CPU @ 3.60GHz
BenchmarkUnmarshalSimple/v2-8         	 1692444	       710.7 ns/op
BenchmarkUnmarshalSimple/v1-8         	  307609	      3862 ns/op
BenchmarkUnmarshalSimple/bs-8         	  520429	      2285 ns/op
BenchmarkReferenceFile/v2-8           	   50395	     24006 ns/op	    6704 B/op	     148 allocs/op
BenchmarkReferenceFile/v1-8           	    4144	    264655 ns/op	  130567 B/op	    2649 allocs/op
BenchmarkReferenceFile/bs-8           	    3969	    293635 ns/op	   80784 B/op	    1729 allocs/op
PASS
ok  	github.com/pelletier/go-toml/v2/benchmark	8.143s
```

parser.go

@@ -11,30 +11,63 @@ import (
 
 type parser struct {
 	builder ast.Builder
+	ref     ast.Reference
+	data    []byte
+	left    []byte
+	err     error
+	first   bool
 }
 
-func (p *parser) parse(b []byte) error {
-	last, b, err := p.parseExpression(b)
-	if err != nil {
-		return err
+func (p *parser) Reset(b []byte) {
+	p.builder.Reset()
+	p.ref = ast.Reference{}
+	p.data = b
+	p.left = b
+	p.err = nil
+	p.first = true
+}
+
+func (p *parser) NextExpression() bool {
+	if len(p.left) == 0 || p.err != nil {
+		return false
 	}
-	for len(b) > 0 {
-		b, err = p.parseNewline(b)
-		if err != nil {
-			return err
+
+	p.builder.Reset()
+	p.ref = ast.Reference{}
+
+	for {
+		if len(p.left) == 0 || p.err != nil {
+			return false
 		}
 
-		var next ast.Reference
-		next, b, err = p.parseExpression(b)
-		if err != nil {
-			return err
+		if !p.first {
+			p.left, p.err = p.parseNewline(p.left)
 		}
-		if next.Valid() {
-			p.builder.Chain(last, next)
-			last = next
+
+		if len(p.left) == 0 || p.err != nil {
+			return false
 		}
+
+		p.ref, p.left, p.err = p.parseExpression(p.left)
+
+		if p.err != nil {
+			return false
+		}
+
+		if p.ref.Valid() {
+			return true
+		}
+
+		p.first = false
 	}
-	return nil
+}
+
+func (p *parser) Expression() ast.Node {
+	return p.builder.NodeAt(p.ref)
+}
+
+func (p *parser) Error() error {
+	return p.err
 }
 
 func (p *parser) parseNewline(b []byte) ([]byte, error) {