## `BETWEEN` keyword misidentified as a Name when followed by a leading-dot float literal

### Description

When parsing a SQL statement that uses `BETWEEN` with float literals written without a leading zero (e.g. `.03`, `.06`), sqlparse incorrectly demotes `BETWEEN` from a keyword token to a `Name` token. The float bounds are also no longer recognized as standalone number tokens.

This can be reproduced as follows:

```python
import sqlparse
from sqlparse import tokens as T

sql = "a BETWEEN .03 AND .06"
p = sqlparse.parse(sql)[0]

# Check that BETWEEN is recognized as a keyword
kw = p.token_next_by(m=(T.Keyword, 'BETWEEN'))[1]
print("BETWEEN token:", kw)  # prints None — BETWEEN is not found as a keyword!

# Check that the float literals are recognized
floats = [t for t in p.flatten() if t.ttype is T.Number.Float]
print("Float tokens:", [t.value for t in floats])  # prints [] — no floats found!
```

The same issue occurs with lowercase: `a between .03 and .06`.

### Expected behavior

- `BETWEEN` (and `between`) should be recognized as a `T.Keyword` token.
- `.03` and `.06` should each be recognized as `T.Number.Float` tokens.
- `AND` should remain a keyword token.

### Actual behavior

`BETWEEN` is classified as a `Name` token (not a keyword), the float bounds `.03` and `.06` are not identified as standalone float tokens, and the overall statement is grouped incorrectly. The `BETWEEN` keyword lookup returns `None`.

### Root cause

The lexer rule for `schema.name` member access — which matches a word followed by a period — also fires when `BETWEEN` appears before a float literal like `.03`. The period at the start of `.03` is mistakenly treated as a member-access operator, causing `BETWEEN` to be reclassified as a `Name`.

Work in `/workspace`. Submit your fix in the existing Python source files under `sqlparse`. Preserve the other public behavior. The environment is offline; dependencies are preinstalled. Grading runs the repository's test suite in a fresh environment, using your submitted source files.