fix(codegen): Convert string literals in tuples to owned Strings (Refs DEPYLER-0682)

Python tuple literals containing strings like [(1, "a"), (2, "b")] were
generating inconsistent Rust types - some elements had .to_string() and
others were raw &str literals. This caused type mismatch errors when the
tuples were used in Vec collections.

Changes:
- Updated convert_tuple() to apply .to_string() to string literals
- Ensures all string elements in tuples become owned Strings
- Maintains type consistency in Vec<(i32, i32, String)> patterns

Example transformation:
  signs = [(1, 20, "Capricorn"), (2, 19, "Aquarius")]

Now consistently generates:
  vec![(1, 20, "Capricorn".to_string()), (2, 19, "Aquarius".to_string())]

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

Co-Authored-By: Claude <[email protected]>

Author: noahgift

crates/depyler-core/src/rust_gen/expr_gen.rs

@@ -13457,9 +13457,20 @@ impl<'a, 'b> ExpressionConverter<'a, 'b> {
     }
 
     fn convert_tuple(&mut self, elts: &[HirExpr]) -> Result<syn::Expr> {
+        // DEPYLER-0682: Convert string literals in tuples to owned Strings
+        // When tuples are used in lists (e.g., Vec<(i32, i32, String)>), string
+        // elements need to be owned Strings, not &str references.
+        // This ensures type consistency across all tuple elements in a Vec.
         let elt_exprs: Vec<syn::Expr> = elts
             .iter()
-            .map(|e| e.to_rust_expr(self.ctx))
+            .map(|e| {
+                let mut expr = e.to_rust_expr(self.ctx)?;
+                // Convert string literals to .to_string() for owned String
+                if matches!(e, HirExpr::Literal(Literal::String(_))) {
+                    expr = parse_quote! { #expr.to_string() };
+                }
+                Ok(expr)
+            })
             .collect::<Result<Vec<_>>>()?;
         Ok(parse_quote! { (#(#elt_exprs),*) })
     }