transform: split interface and reflect lowering

These two passes are related, but can definitely work independently.
Which is what this change does: it splits the two passes. This should
make it easier to change these two new passes in the future.

This change now also enables slightly better testing by testing these
two passes independently. In particular, the reflect lowering pass got
some actual tests: it was barely unit-tested before.

I have verified that this doesn't really change code size, at least not
on the microbit target. Two tests do change, but in a very minor way
(and in opposite direction).

transform/allocs_test.go

@@ -2,7 +2,6 @@ package transform_test
 
 import (
 	"go/token"
-	"go/types"
 	"io/ioutil"
 	"path/filepath"
 	"regexp"
@@ -11,9 +10,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/compiler"
-	"github.com/tinygo-org/tinygo/loader"
 	"github.com/tinygo-org/tinygo/transform"
 	"tinygo.org/x/go-llvm"
 )
@@ -39,52 +35,7 @@ func (out allocsTestOutput) String() string {
 func TestAllocs2(t *testing.T) {
 	t.Parallel()
 
-	target, err := compileopts.LoadTarget("i686--linux")
-	if err != nil {
-		t.Fatal("failed to load target:", err)
-	}
-	config := &compileopts.Config{
-		Options: &compileopts.Options{},
-		Target:  target,
-	}
-	compilerConfig := &compiler.Config{
-		Triple:             config.Triple(),
-		GOOS:               config.GOOS(),
-		GOARCH:             config.GOARCH(),
-		CodeModel:          config.CodeModel(),
-		RelocationModel:    config.RelocationModel(),
-		Scheduler:          config.Scheduler(),
-		FuncImplementation: config.FuncImplementation(),
-		AutomaticStackSize: config.AutomaticStackSize(),
-		Debug:              true,
-	}
-	machine, err := compiler.NewTargetMachine(compilerConfig)
-	if err != nil {
-		t.Fatal("failed to create target machine:", err)
-	}
-
-	// Load entire program AST into memory.
-	lprogram, err := loader.Load(config, []string{"./testdata/allocs2.go"}, config.ClangHeaders, types.Config{
-		Sizes: compiler.Sizes(machine),
-	})
-	if err != nil {
-		t.Fatal("failed to create target machine:", err)
-	}
-	err = lprogram.Parse()
-	if err != nil {
-		t.Fatal("could not parse", err)
-	}
-
-	// Compile AST to IR.
-	program := lprogram.LoadSSA()
-	pkg := lprogram.MainPkg()
-	mod, errs := compiler.CompilePackage("allocs2.go", pkg, program.Package(pkg.Pkg), machine, compilerConfig, false)
-	if errs != nil {
-		for _, err := range errs {
-			t.Error(err)
-		}
-		return
-	}
+	mod := compileGoFileForTesting(t, "./testdata/allocs2.go")
 
 	// Run functionattrs pass, which is necessary for escape analysis.
 	pm := llvm.NewPassManager()