Efficient lookups and traversal

When implementing search, comparison, or traversal logic, avoid unnecessary linear scans or redundant recomputation. Choose data structures and built-in utilities that match the access pattern, and bound the work to exactly what is needed.

• Prefer O(1) lookups over O(n) iteration when checking for existence or conflicts. For example, instead of calling iter_rules() and scanning every rule to detect a duplicate (subdomain, method, path) combination, maintain a set of these tuples and check membership in it.
• Use well-tested stdlib algorithms instead of hand-rolled equivalents, and verify their semantics before relying on them. os.path.commonprefix operates on strings, not paths, and can give wrong results when one path is not an ancestor of another; prefer os.path.commonpath (or carefully verify prefix/ancestor logic, including edge cases like top_dir and cwd being on different branches) when comparing directories.
• Limit algorithmic work to what’s required. When splitting a string where only one split is needed, pass an explicit maxsplit rather than splitting unboundedly: re.split(pattern, value, 1) instead of re.split(pattern, value).
• When traversing a class hierarchy or similar precomputed structure, use the attribute that already holds the computed result (e.g. cls.__mro__) instead of recomputing it via a method call (cls.mro()), unless recomputation is specifically required.

Double-check boundary conditions (e.g., inverted comparisons, off-by-one errors in prefix matching) when writing traversal or comparison logic, since these are common sources of subtle bugs in otherwise efficient algorithms.