Address code review feedback for LTR visual transformations

Simplifies password field visual transformations and adds comprehensive
documentation to clarify usage patterns for future contributors.

Changes:
- Remove unnecessary CompoundVisualTransformation when password is obscured
  (bullets are directionally neutral)
- Change ForceLtrVisualTransformation and CompoundVisualTransformation
  visibility from private to internal for testability
- Add comprehensive KDoc explaining when to use LTR transformation:
  * Apply to technical identifiers (SSN, passport, license, etc.)
  * Do NOT apply to locale-dependent text (names, addresses, usernames)
- Add usage examples to CompoundVisualTransformation
- Create comprehensive test suites (39 test cases) to verify offset
  mapping correctness and edge case handling

All tests pass and code compiles successfully.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: SaintPatrck

ui/src/main/kotlin/com/bitwarden/ui/platform/components/field/BitwardenHiddenPasswordField.kt

@@ -16,8 +16,6 @@ import com.bitwarden.ui.platform.base.util.nullableTestTag
 import com.bitwarden.ui.platform.components.field.color.bitwardenTextFieldColors
 import com.bitwarden.ui.platform.components.field.toolbar.BitwardenEmptyTextToolbar
 import com.bitwarden.ui.platform.components.model.CardStyle
-import com.bitwarden.ui.platform.components.util.compoundVisualTransformation
-import com.bitwarden.ui.platform.components.util.forceLtrVisualTransformation
 import com.bitwarden.ui.platform.theme.BitwardenTheme
 
 /**
@@ -46,10 +44,7 @@ fun BitwardenHiddenPasswordField(
             label = label?.let { { Text(text = it) } },
             value = value,
             onValueChange = { },
-            visualTransformation = compoundVisualTransformation(
-                PasswordVisualTransformation(),
-                forceLtrVisualTransformation(),
-            ),
+            visualTransformation = PasswordVisualTransformation(),
             singleLine = true,
             enabled = false,
             readOnly = true,

ui/src/main/kotlin/com/bitwarden/ui/platform/components/field/BitwardenPasswordField.kt

@@ -143,10 +143,7 @@ fun BitwardenPasswordField(
     var lastTextValue by remember(value) { mutableStateOf(value = value) }
 
     val visualTransformation = when {
-        !showPassword -> compoundVisualTransformation(
-            PasswordVisualTransformation(),
-            forceLtrVisualTransformation(),
-        )
+        !showPassword -> PasswordVisualTransformation()
 
         readOnly -> compoundVisualTransformation(
             nonLetterColorVisualTransformation(),

ui/src/main/kotlin/com/bitwarden/ui/platform/components/util/CompoundVisualTransformation.kt

@@ -10,10 +10,43 @@ import androidx.compose.ui.text.input.VisualTransformation
 /**
  * A [VisualTransformation] that chains multiple other [VisualTransformation]s.
  *
- * This is useful for applying multiple transformations to a text field. The transformations
- * are applied in the order they are provided.
+ * This is useful for applying multiple transformations to a text field. The
+ * transformations are applied in the order they are provided, with each transformation's
+ * output becoming the input for the next transformation.
+ *
+ * ## Example Usage
+ *
+ * Combining password masking with LTR direction enforcement:
+ * ```kotlin
+ * val visualTransformation = compoundVisualTransformation(
+ *     PasswordVisualTransformation(),
+ *     forceLtrVisualTransformation()
+ * )
+ * TextField(
+ *     value = password,
+ *     visualTransformation = visualTransformation
+ * )
+ * ```
+ *
+ * Combining color transformation with LTR for readonly fields:
+ * ```kotlin
+ * val visualTransformation = compoundVisualTransformation(
+ *     nonLetterColorVisualTransformation(),
+ *     forceLtrVisualTransformation()
+ * )
+ * ```
+ *
+ * ## Important Notes
+ *
+ * - Offset mapping is correctly composed through all transformations
+ * - The order of transformations matters (first applied is first in the list)
+ * - Use [compoundVisualTransformation] function for proper `remember` optimization
+ *
+ * @param transformations The visual transformations to apply in order
+ * @see compoundVisualTransformation
+ * @see forceLtrVisualTransformation
  */
-private class CompoundVisualTransformation(
+internal class CompoundVisualTransformation(
     vararg val transformations: VisualTransformation,
 ) : VisualTransformation {
     override fun filter(text: AnnotatedString): TransformedText {

ui/src/main/kotlin/com/bitwarden/ui/platform/components/util/ForceLtrVisualTransformation.kt

@@ -9,16 +9,48 @@ import androidx.compose.ui.text.input.TransformedText
 import androidx.compose.ui.text.input.VisualTransformation
 
 // Unicode characters for forcing LTR direction
-private const val LRO = "\u202A"
-private const val PDF = "\u202C"
+internal const val LRO = "\u202A"
+internal const val PDF = "\u202C"
 
 /**
  * A [VisualTransformation] that forces the output to have an LTR text direction.
  *
- * This is useful for password fields where the input should always be LTR, even when the rest of
- * the UI is RTL.
+ * This transformation wraps text with Unicode directional control characters (LRO/PDF)
+ * to ensure left-to-right rendering regardless of the UI's locale or text direction.
+ *
+ * ## When to Use
+ *
+ * Apply this transformation to fields containing **standardized, technical data** that is
+ * always interpreted from left-to-right, regardless of locale:
+ * - Passwords and sensitive authentication data
+ * - Social Security Numbers (SSN)
+ * - Driver's license numbers
+ * - Passport numbers
+ * - Payment card numbers
+ * - Email addresses (technical format)
+ * - Phone numbers (standardized format)
+ * - URIs and technical identifiers
+ *
+ * ## When NOT to Use
+ *
+ * Do NOT apply this transformation to **locale-dependent text** that may legitimately
+ * use RTL scripts:
+ * - Personal names (may use Arabic, Hebrew, etc.)
+ * - Company names
+ * - Addresses
+ * - Usernames (user choice)
+ * - Notes and other free-form text
+ *
+ * ## Implementation Notes
+ *
+ * - Only applies LTR transformation when text is **visible**
+ * - Do NOT use with obscured text (e.g., password bullets) as masked characters
+ *   are directionally neutral
+ * - Can be composed with other transformations using [compoundVisualTransformation]
+ *
+ * @see compoundVisualTransformation
  */
-private object ForceLtrVisualTransformation : VisualTransformation {
+internal object ForceLtrVisualTransformation : VisualTransformation {
     override fun filter(text: AnnotatedString): TransformedText {
         val forcedLtrText = buildAnnotatedString {
             append(LRO)
@@ -38,7 +70,7 @@ private object ForceLtrVisualTransformation : VisualTransformation {
 }
 
 /**
- * Remembers a [ForceLtrVisualTransformation] for the given [transformations].
+ * Remembers a [ForceLtrVisualTransformation] transformation.
  *
  * This is an optimization to avoid creating a new [ForceLtrVisualTransformation] on every
  * recomposition.