Close combined-case gap: backtick AND default-escape char in same name

A column named e.g. `col`x.y` (literal backtick + dot) failed to
round-trip because the two escape mechanisms interacted incorrectly:

  1. Our override doubles the backtick: name -> `col``x.y`
  2. Super's bindname_escape_characters then translates the dot:
     name -> `col``x_y`, escaped_from -> `col``x.y`
  3. escaped_bind_names records {col``x.y: col``x_y}
  4. bind_names[bindparam] is the original `col`x.y` (single backtick,
     set by _truncate_bindparam before our override runs)
  5. construct_params looks up `col`x.y` in escaped_bind_names —
     misses (the key is doubled), so dict key stays `col`x.y`
  6. Server parses marker name `col`x_y` (dot translated, backtick
     un-doubled), looks up `col`x_y` in the dict — UNBOUND.

Fix: when our override doubles backticks, render the marker fully
ourselves rather than delegating to super. Keeps escaped_bind_names
empty for these names so construct_params passes the original key
through unchanged. Super's escape map can no longer interact with our
doubled name. The non-backtick path (e.g. plain `col.x`) is unchanged
and still goes through super.

Adds a unit test and an end-to-end audit case for `col`x.y`. Audit is
now 43/43 (added 2 new assertions for the combined case). Vanishingly
rare in practice but it's the last realistic edge case I could
identify; closing it removes the only known correctness gap.

Signed-off-by: Madhavendra Rathore <madhavendra.rathore@databricks.com>

Author: msrathore-db

src/databricks/sqlalchemy/_ddl.py

@@ -138,15 +138,31 @@ def bindparam_string(self, name, **kw):
         # ``BACKQUOTED_IDENTIFIER`` lexer rule. The doubling affects only
         # the rendered SQL; the params dict key sent to the driver stays
         # the single-backtick original (the server collapses ``  ->  `
-        # when it parses the marker name), so we must not set
-        # ``escaped_from`` — leaving ``escaped_bind_names`` empty keeps
-        # the key translation in ``construct_params`` a no-op.
+        # when it parses the marker name).
+        #
+        # When a backtick is present, render the marker ourselves rather
+        # than delegating to super. Super would otherwise also apply
+        # ``bindname_escape_characters`` translation (``.``->``_``,
+        # ``[``->``_``, etc.) AND set ``escaped_from``, which together
+        # would propagate into ``escaped_bind_names`` and rewrite the
+        # params-dict key. The original dict key uses a single backtick
+        # and the un-translated form, so the rewrite would create a
+        # mismatch with what the server expects when it parses the
+        # backtick-quoted marker name. By owning the rendering here we
+        # keep ``escaped_bind_names`` empty for these names and the dict
+        # key passes through unchanged.
         if (
             "`" in name
             and not kw.get("escaped_from")
             and not kw.get("post_compile", False)
         ):
-            name = name.replace("`", "``")
+            accumulate = kw.get("accumulate_bind_names")
+            if accumulate is not None:
+                accumulate.add(name)
+            visited = kw.get("visited_bindparam")
+            if visited is not None:
+                visited.append(name)
+            return self._BIND_TEMPLATE % {"name": name.replace("`", "``")}
         return super().bindparam_string(name, **kw)
 
     def limit_clause(self, select, **kw):