We're planning to disallow that soon. See #15540 (comment) for context.

Actually, wait. #15540 is only about object names. For arbitrary identifiers we actually do need dots (e.g. x.slot and x.offset are identifiers). So it's more of a documentation issue.

It actually is documented, in multiple places.

Yul > Syntax

There is one exception: Identifiers in Yul can contain dots: ..

Language Grammar > YulIdentifier

Yul identifiers consist of letters, dollar signs, underscores and numbers, but may not start with a number. In inline assembly there cannot be dots in user-defined identifiers. Instead see yulPath for expressions consisting of identifiers with dots.

Solidity v0.7.0 Breaking Changes > Inline Assembly

• Disallow . in user-defined function and variable names in inline assembly. It is still valid if you use Solidity in Yul-only mode.

Though looks like we don't mention it under Inline Assembly. We should add it there as well.

Also note that Language Grammar reflects Solidity grammar. The one for pure Yul is under Yul > Specification of Yul.

Actually, it's already on the Inline Assembly page as well:

Since Solidity 0.7.0, variables and functions declared inside the
inline assembly block may not contain ., but using . is
valid to access Solidity variables from outside the inline assembly block.

The language grammar specifies yul-variable-declaration: let yul-identifier := ..., yul-identifier = [a-zA-Z$_][a-zA-Z0-9$_]* so it's mismatched with the description or with uses of this rule; also dotted identifier paths are apparently treated as single identifiers AFAICT in the source code.

The Solidity grammar for yul identifiers states that In inline assembly there cannot be dots in user-defined identifiers.

Yul identifiers consist of letters, dollar signs, underscores and numbers, but may not start with a number. In inline assembly there cannot be dots in user-defined identifiers. Instead see yulPath for expressions consisting of identifiers with dot

The Yul specification defines an identifier with the rule Identifier = [a-zA-Z_$] [a-zA-Z_$0-9.]*, i.e, dots are accepted.

So, to be clear, in Solidity, yul code, which can only appear inside inline assembly blocks, doesn't accept dots in user-defined identifiers, albeit it accepts dots if they are referencing variables outside the scope of the block (such as .slot or .offset for storage variables). On the other hand, pure Yul code accepts dots in identifiers, regardless if they are user-defined or not.

Examples:
Solidity doesn't accept dots in user-defined identifiers:

contract A {
    function f() public pure returns (uint x) {
        assembly {
                let z.a := mload(0)
                x := z.a
        }
    }
}

Error: User-defined identifiers in inline assembly cannot contain '.'.

Pure Yul does accept dots in user-defined identifiers:

{
    let z.a := mload(0)
    let x.y.z := add(z.a, 0x2A)
    mstore(z.a, x.y.z)
}

Pretty printed source:
object "object" {
code {
{
let z.a := mload(0)
let x.y.z := add(z.a, 0x2A)
mstore(z.a, x.y.z)
}
}
}
Binary representation:
5f51602a8101905200
Text representation:
/* "test.yul":68:69 /
0x00
/ "test.yul":62:70 /
mload
/ "test.yul":105:109 /
0x2a
/ "test.yul":96:110 /
dup2
add
/ "test.yul":123:141 /
swap1
mstore
/ "test.yul":27:157 */
stop

also dotted identifier paths are apparently treated as single identifiers AFAICT in the source code.

Only in Yul mode.