tpl/tplimpl: Rework template management to get rid of concurrency issues

This more or less completes the simplification of the template handling code in Hugo started in v0.62.

The main motivation was to fix a long lasting issue about a crash in HTML content files  without front matter.

But this commit also comes with a big functional improvement.

As we now have moved the base template evaluation to the build stage we now use the same lookup rules for `baseof` as for `list` etc. type of templates.

This means that in this simple example you can have a `baseof` template for the `blog` section without having to duplicate the others:

```
layouts
├── _default
│   ├── baseof.html
│   ├── list.html
│   └── single.html
└── blog
    └── baseof.html
```

Also, when simplifying code, you often get rid of some double work, as shown in the "site building" benchmarks below.

These benchmarks looks suspiciously good, but I have repeated the below with ca. the same result. Compared to master:

```
name                              old time/op    new time/op    delta
SiteNew/Bundle_with_image-16        13.1ms ± 1%    10.5ms ± 1%  -19.34%  (p=0.029 n=4+4)
SiteNew/Bundle_with_JSON_file-16    13.0ms ± 0%    10.7ms ± 1%  -18.05%  (p=0.029 n=4+4)
SiteNew/Tags_and_categories-16      46.4ms ± 2%    43.1ms ± 1%   -7.15%  (p=0.029 n=4+4)
SiteNew/Canonify_URLs-16            52.2ms ± 2%    47.8ms ± 1%   -8.30%  (p=0.029 n=4+4)
SiteNew/Deep_content_tree-16        77.9ms ± 1%    70.9ms ± 1%   -9.01%  (p=0.029 n=4+4)
SiteNew/Many_HTML_templates-16      43.0ms ± 0%    37.2ms ± 1%  -13.54%  (p=0.029 n=4+4)
SiteNew/Page_collections-16         58.2ms ± 1%    52.4ms ± 1%   -9.95%  (p=0.029 n=4+4)

name                              old alloc/op   new alloc/op   delta
SiteNew/Bundle_with_image-16        3.81MB ± 0%    2.22MB ± 0%  -41.70%  (p=0.029 n=4+4)
SiteNew/Bundle_with_JSON_file-16    3.60MB ± 0%    2.01MB ± 0%  -44.20%  (p=0.029 n=4+4)
SiteNew/Tags_and_categories-16      19.3MB ± 1%    14.1MB ± 0%  -26.91%  (p=0.029 n=4+4)
SiteNew/Canonify_URLs-16            70.7MB ± 0%    69.0MB ± 0%   -2.40%  (p=0.029 n=4+4)
SiteNew/Deep_content_tree-16        37.1MB ± 0%    31.2MB ± 0%  -15.94%  (p=0.029 n=4+4)
SiteNew/Many_HTML_templates-16      17.6MB ± 0%    10.6MB ± 0%  -39.92%  (p=0.029 n=4+4)
SiteNew/Page_collections-16         25.9MB ± 0%    21.2MB ± 0%  -17.99%  (p=0.029 n=4+4)

name                              old allocs/op  new allocs/op  delta
SiteNew/Bundle_with_image-16         52.3k ± 0%     26.1k ± 0%  -50.18%  (p=0.029 n=4+4)
SiteNew/Bundle_with_JSON_file-16     52.3k ± 0%     26.1k ± 0%  -50.16%  (p=0.029 n=4+4)
SiteNew/Tags_and_categories-16        336k ± 1%      269k ± 0%  -19.90%  (p=0.029 n=4+4)
SiteNew/Canonify_URLs-16              422k ± 0%      395k ± 0%   -6.43%  (p=0.029 n=4+4)
SiteNew/Deep_content_tree-16          401k ± 0%      313k ± 0%  -21.79%  (p=0.029 n=4+4)
SiteNew/Many_HTML_templates-16        247k ± 0%      143k ± 0%  -42.17%  (p=0.029 n=4+4)
SiteNew/Page_collections-16           282k ± 0%      207k ± 0%  -26.55%  (p=0.029 n=4+4)
```

Fixes #6716
Fixes #6760
Fixes #6768
Fixes #6778

1 files changed, 28 insertions, 40 deletions

diff --git a/hugolib/page.go b/hugolib/page.go
index 8aad8dcc7..bb5107747 100644
--- a/hugolib/page.go
+++ b/hugolib/page.go
@@ -337,37 +337,33 @@ func (p *pageState) createRenderHooks(f output.Format) (*hooks.Render, error) {
 	layoutDescriptor.Layout = ""
 
 	layoutDescriptor.Kind = "render-link"
-	linkLayouts, err := p.s.layoutHandler.For(layoutDescriptor, f)
+	linkTempl, linkTemplFound, err := p.s.Tmpl().LookupLayout(layoutDescriptor, f)
 	if err != nil {
 		return nil, err
 	}
 
 	layoutDescriptor.Kind = "render-image"
-	imageLayouts, err := p.s.layoutHandler.For(layoutDescriptor, f)
+	imgTempl, imgTemplFound, err := p.s.Tmpl().LookupLayout(layoutDescriptor, f)
 	if err != nil {
 		return nil, err
 	}
 
-	if linkLayouts == nil && imageLayouts == nil {
-		return nil, nil
-	}
-
 	var linkRenderer hooks.LinkRenderer
 	var imageRenderer hooks.LinkRenderer
 
-	if templ, found := p.s.lookupTemplate(linkLayouts...); found {
+	if linkTemplFound {
 		linkRenderer = contentLinkRenderer{
-			templateHandler: p.s.Tmpl,
-			Provider:        templ.(tpl.Info),
-			templ:           templ,
+			templateHandler: p.s.Tmpl(),
+			Provider:        linkTempl.(tpl.Info),
+			templ:           linkTempl,
 		}
 	}
 
-	if templ, found := p.s.lookupTemplate(imageLayouts...); found {
+	if imgTemplFound {
 		imageRenderer = contentLinkRenderer{
-			templateHandler: p.s.Tmpl,
-			Provider:        templ.(tpl.Info),
-			templ:           templ,
+			templateHandler: p.s.Tmpl(),
+			Provider:        imgTempl.(tpl.Info),
+			templ:           imgTempl,
 		}
 	}
 
@@ -406,24 +402,25 @@ func (p *pageState) getLayoutDescriptor() output.LayoutDescriptor {
 
 }
 
-func (p *pageState) getLayouts(layouts ...string) ([]string, error) {
+func (p *pageState) resolveTemplate(layouts ...string) (tpl.Template, bool, error) {
 	f := p.outputFormat()
 
 	if len(layouts) == 0 {
 		selfLayout := p.selfLayoutForOutput(f)
 		if selfLayout != "" {
-			return []string{selfLayout}, nil
+			templ, found := p.s.Tmpl().Lookup(selfLayout)
+			return templ, found, nil
 		}
 	}
 
-	layoutDescriptor := p.getLayoutDescriptor()
+	d := p.getLayoutDescriptor()
 
 	if len(layouts) > 0 {
-		layoutDescriptor.Layout = layouts[0]
-		layoutDescriptor.LayoutOverride = true
+		d.Layout = layouts[0]
+		d.LayoutOverride = true
 	}
 
-	return p.s.layoutHandler.For(layoutDescriptor, f)
+	return p.s.Tmpl().LookupLayout(d, f)
 }
 
 // This is serialized
@@ -601,31 +598,21 @@ func (p *pageState) RenderWithTemplateInfo(info tpl.Info, layout ...string) (tem
 }
 
 func (p *pageState) Render(layout ...string) (template.HTML, error) {
-	l, err := p.getLayouts(layout...)
+	templ, found, err := p.resolveTemplate(layout...)
 	if err != nil {
-		return "", p.wrapError(errors.Errorf("failed to resolve layout %v", layout))
+		return "", p.wrapError(err)
 	}
 
-	for _, layout := range l {
-		templ, found := p.s.Tmpl.Lookup(layout)
-		if !found {
-			// This is legacy from when we had only one output format and
-			// HTML templates only. Some have references to layouts without suffix.
-			// We default to good old HTML.
-			templ, _ = p.s.Tmpl.Lookup(layout + ".html")
-		}
-
-		if templ != nil {
-			p.addDependency(templ.(tpl.Info))
-			res, err := executeToString(p.s.Tmpl, templ, p)
-			if err != nil {
-				return "", p.wrapError(errors.Wrapf(err, "failed to execute template %q v", layout))
-			}
-			return template.HTML(res), nil
-		}
+	if !found {
+		return "", nil
 	}
 
-	return "", nil
+	p.addDependency(templ.(tpl.Info))
+	res, err := executeToString(p.s.Tmpl(), templ, p)
+	if err != nil {
+		return "", p.wrapError(errors.Wrapf(err, "failed to execute template %q v", layout))
+	}
+	return template.HTML(res), nil
 
 }
 
@@ -689,6 +676,7 @@ Loop:
 			// This is HTML without front matter. It can still have shortcodes.
 			p.selfLayout = "__" + p.File().Filename()
 			p.renderable = false
+			p.s.BuildFlags.HasLateTemplate.CAS(false, true)
 			rn.AddBytes(it)
 		case it.IsFrontMatter():
 			f := metadecoders.FormatFromFrontMatterType(it.Type)