### Description

This was flagged by @romseygeek in https://github.com/elastic/elasticsearch/pull/95558#discussion_r1177625654 to be targeted for a new issue.

In dynamic_template mappings, 'simple' match types (which is the default setting) will happily accept regexes (rather than simple wildcards) without error or warning, but then they will not work as the user likely intended. We should emit a warning if the user provides a pattern that 'looks like' a regex, but haven't explicitly set match_type.

---- 

Deeper context: 

The validate method in DynamicTemplate.parse tries to catch these, but it only catches the invalid pattern when match_pattern=regex. For example, see the test: https://github.com/elastic/elasticsearch/blob/main/server/src/test/java/org/elasticsearch/index/mapper/DynamicTemplateParseTests.java#L132

Current behavior is:

```
  "mappings": {
    "dynamic_templates": [
      {
        "mytemplate": {
          "match_pattern": "regex",
          "match": "*name",
          "unmatch": "*middle",
          "mapping": {
            "type": "keyword"
          }
        }
      }
    ]
  }
```
fails with:
```
    "type": "mapper_parsing_exception",
    "reason": "Failed to parse mapping: Pattern [*name] of type [regex] is invalid. Cannot create dynamic template [mytemplate].",\
```
but:

```
      {
        "mytemplate": {
          "match": ".*name$",
          "unmatch": "^.*middle.*",
          "mapping": {
            "type": "keyword"
          }
        }
      }
```
(where  `"match_pattern": "simple"` is implied) works with no problems (until you try to actually put documents in with the mapping, of course).

We could probably add a method to Regex.java. There is already this function

```
   public static boolean isSimpleMatchPattern(String str) {
        return str.indexOf('*') != -1;
    }
```
but that's not enough for this scenario.

[This code](https://github.com/elastic/elasticsearch/blob/main/server/src/main/java/org/elasticsearch/common/regex/Regex.java#L133) indicates that the only allowed patterns for "simple" are "xxx*", "*xxx", "*xxx*" and "xxx*yyy", so we could check for things like .* and ^xxx and yyy$ and chars like [, ] and | and maybe parens and then run it through [REGEX.matches()](https://github.com/elastic/elasticsearch/blob/main/server/src/main/java/org/elasticsearch/index/mapper/DynamicTemplate.java#L40) and if that does NOT fail, then it appears to be a valid actual regex, not a simple pattern and then give a warning to users.
server/src/test/java/org/elasticsearch/index/mapper/DynamicTemplatesTests.java
{
                                b.startObject("raw").field("type", "keyword").endObject();
                            }
                            b.endObject();
                        }
                        b.endObject();
                    }
                    b.endObject();
                }
                b.endObject();
            }
            b.endArray();
        }));
        assertNull(mapperService.documentMapper().mappers().getMapper("field.raw"));
        ParsedDocument parsed = mapperService.documentMapper().parse(source(b -> b.field("field", "foo")));
        assertNotNull(parsed.dynamicMappingsUpdate());
        merge(mapperService, dynamicMapping(parsed.dynamicMappingsUpdate()));
        assertNotNull(mapperService.documentMapper().mappers().getMapper("field.raw"));
        parsed = mapperService.documentMapper().parse(source(b -> b.field("field", "foo")));
        assertNull(parsed.dynamicMappingsUpdate());
    }
    public void testDateDetectionInheritsFormat() throws Exception {
        MapperService mapperService = createMapperService(topMapping(b -> {
            b.startArray("dynamic_date_formats").value("yyyy-MM-dd").endArray();
            b.startArray("dynamic_templates");
            {
                b.startObject();
                {
                    b.startObject("dates");
                    {