Wildcards within, and between, lines behave very differently, so split
them into two different constants. Right now this doesn't make any
difference (the constants are the same!), but it makes it clearer in the
code which is which at different points.

This is so, when we shortly add new syntax, we can warn users of the
change.

This means only having to edit one file instead of keeping two
nearly-identical things in sync. It also means that the doc strings in
the README are tested.

This allows "group matching", which also implies backtracing.

Consider this pattern:

```text
A
..?
B
C
..?
```

This will match successfully against the literal:

```text
A
D
B
C
E
```

but fail to match against the literal:

```text
A
D
B
B
C
E
```

because the `..?` matched against the first "B", anchored the search, then
immediately failed to match against the second "B".

In contrast the pattern:

```text
A
..*
B
C
..?
```

will, through backtracing, successfully match the literal.

```text
A
..?
B
C
..*
D
E
```

There are two reasons why you should default to using `..?` rather than `..*`.
Most obviously `..?` does not backtrack and has linear performance. Less
obviously `..?` prevents literals from matching when they contain multiple
similar sequences. Informally, `..?` makes for more rigorous testing: `..?` can
be thought of as "the next thing that matches must look like X" whereas `..*`
says "skip things that are almost like X until you find something that is
definitely X".

Consider this pattern:

```text
A
..?
B
C
..?
```

This will match successfully against the literal:

```text
A
D
B
C
E
```

but fail to match against the literal:

```text
A
D
B
B
C
E
```

because the `..?` matched against the first "B", anchored the search, then
immediately failed to match against the second "B".

In contrast the pattern:

```text
A
..*
B
C
..?
```

will, through backtracing, successfully match the literal.

```text
A
..?
B
C
..*
D
E
```

There are two reasons why you should default to using `..?` rather than `..*`.
Most obviously `..?` does not backtrack and has linear performance. Less
obviously `..?` prevents literals from matching when they contain multiple
similar sequences. Informally, `..?` makes for more rigorous testing: `..?` can
be thought of as "the next thing that matches must look like X" whereas `..*`
says "skip things that are almost like X until you find something that is
definitely X".