Avoid problems with val being undefined in the federation template. (…

…#1760)

* Avoid problems with `val` being undefined in the federation template.

When running gqlgen over our schema, we were seeing errors like:
```
assignments/generated/graphql/service.go:300:4: val declared but not used
```

The generated code looks like this:
```
func entityResolverNameForMobileNavigation(ctx context.Context, rep map[string]interface{}) (string, error) {
        for {
                var (
                        m   map[string]interface{}
                        val interface{}
                        ok  bool
                )
                m = rep
                if _, ok = m["kaid"]; !ok {
                        break
                }
                m = rep
                if _, ok = m["language"]; !ok {
                        break
                }
                return "findMobileNavigationByKaidAndLanguage", nil
        }
        return "", fmt.Errorf("%w for MobileNavigation", ErrTypeNotFound)
}
```

Looking at the code, it's pretty clear that this happens when there
are multiple key-fields, but each of them has only one keyField.Field
entry.  This is because the old code looked at `len(keyFields)` to
decide whether to declare the `val` variable, but looks at
`len(keyField.Field)` for each keyField to decide whether to use the
`val` variable.

The easiest solution, and the one I do in this PR, is to just declare
`val` all the time, and use a null-assignment to quiet the compiler
when it's not used.

* run go generate to update generated files

* run go generate to update moar generated files

* Adding a test for verify that this fixes the issue.

From `plugins/federation`, run the following command and verify that no errors are produced

```
go run github.com/99designs/gqlgen --config testdata/entityresolver/gqlgen.yml
```

Co-authored-by: MiguelCastillo <miguel@khanacademy.org>

plugin/federation/federation.gotpl

@@ -233,11 +233,10 @@ func (ec *executionContext) __resolve_entities(ctx context.Context, representati
 				for {
 					var (
 						m    map[string]interface{}
-						{{- if gt (len .KeyFields) 1 }}
-							val interface{}
-						{{- end }}
+						val interface{}
 						ok bool
 					)
+					_ = val
 					{{- range $_, $keyField := .KeyFields }}
 						m = rep
 						{{- range $i, $field := .Field }}

plugin/federation/testdata/entityresolver/entity.resolvers.go

@@ -16,6 +16,10 @@ func (r *entityResolver) FindHelloByName(ctx context.Context, name string) (*gen
 	}, nil
 }
 
+func (r *entityResolver) FindHelloMultiSingleKeysByKey1AndKey2(ctx context.Context, key1 string, key2 string) (*generated.HelloMultiSingleKeys, error) {
+	panic(fmt.Errorf("not implemented"))
+}
+
 func (r *entityResolver) FindHelloWithErrorsByName(ctx context.Context, name string) (*generated.HelloWithErrors, error) {
 	if name == "inject error" {
 		return nil, generated.ErrResolvingHelloWithErrorsByName