Improve architecture of templates and template configs

[hbjydev]

While trying to implement a new template type on stream, BG ran into a number of issues; however, one of the biggest (and easiest to target) was the amount of coordination there is to do around the codebase to implement a set of templates.

We need something better from a DevEx perspective that makes these easier to do.

---

I'm thinking something along these lines (pseudocode):

type TemplateParameters interface {
  // FillDefaults populates the params struct with default values.
  FillDefaults()
}

// Template represents a renderable template
type Template[T any] struct {
  templates templates.RenderMap
}

// Render renders the template files out to the current directory
func (t Template) Render() error {
  // Logic used to write templates for _every_ template type.
}

// -------------------------

type GoLambdaParameters struct {
  Nix NixConfig `json:"nix" yaml:"nix"`
}

func (p GoLambdaParameters) FillDefaults() {
  p.Nix = NewNixConfig()
}

// -------------------------

var Templates = map[string]Template[TemplateParameters]{
  "go-lambda": Template[GoLambdaParameters]{
    templates: templates.RenderMap{
      templates.GoCommonTemplates{".editorconfig"},
      templates.GoLambdaTemplates{".github/workflows/flake.yaml"},
    },
  },
}

func main() {
  t := Templates["go-lambda"]
  if err := t.Render(); err != nil {
    fmt.Fprintf(os.Stderr, "Failed to render template '%v': %v", t.name, err)
    os.Exit(1)
  }
}

What this pseudocode doesn't cover is finding a better way to implement loading in the templates; maybe we can pass in a template path as part of the TemplateMap type or similar that will load them dynamically during the Render() procedure.