cgen: fix mut generic param indirection under -new-generic-solver

The new generic solver pre-resolves a `mut x T` parameter's type to the
concrete type, dropping the .generic flag, so fn_decl_params skipped adding
the pointer level: it emitted `T x` while the caller passes `&x` and the body
derefs `*x` (C error: pointer expected). Decide the indirection from orig_typ,
which still carries the generic T and resolves via cur_concrete_types.

Fixes all vlib/flag tests and 17 vlib/v/tests/generics tests under
-new-generic-solver; the default compiler is unaffected (self-compiles, all
normal generics tests still pass). Widen the regression test's count tolerance,
since it now also runs on macOS (after the vfmt CI fix), where the absolute
failure count differs from linux.

Author: medvednikov

vlib/v/gen/c/fn.v

@@ -2028,8 +2028,13 @@ fn (mut g Gen) fn_decl_params(params []ast.Param, scope &ast.Scope, is_variadic
 		if g.pref.translated && g.file.is_translated && param.typ.has_flag(.variadic) {
 			typ = g.table.sym(typ).array_info().elem_type.set_flag(.variadic)
 		}
+		// A `mut x T` parameter is passed by reference, so its C type must be a pointer to
+		// the concrete type. The normal solver keeps `.generic` on `param.typ` here, but the
+		// new generic solver pre-resolves `param.typ` to the concrete type (dropping the flag),
+		// so it would otherwise miss the indirection. `param.orig_typ` still carries the
+		// generic `T`, which resolves correctly via `cur_concrete_types`.
 		if param.is_mut && param.orig_typ != 0 && param.orig_typ.has_flag(.generic)
-			&& param.typ.has_flag(.generic) {
+			&& (param.typ.has_flag(.generic) || g.pref.new_generic_solver) {
 			mut surface_typ := g.unwrap_generic(param.orig_typ)
 			// Only use ref() when the pointer comes from the generic type argument
 			// (T=&int), not from the param signature (&T / ?&T).

vlib/v/generics/new_generics_regression_test.v

@@ -68,16 +68,21 @@ fn run_new_generic_solver_tests(root_label string, test_cmd string, expected_sum
 		&& summary_lines.any(it.contains(actual_clean_summary))
 	if !found_expected_summary && !found_clean_summary {
 		// Before failing, check if the actual failure count falls within an acceptable range.
-		// Different compilers (gcc, tcc, clang, msvc) may produce slightly different failure
-		// counts due to compiler-specific C code generation differences.
+		// Different compilers (gcc, tcc, clang, msvc) and host platforms (linux vs macos)
+		// produce different failure counts, both due to compiler-specific C codegen and because
+		// the per-platform test set differs slightly. The `-new-generic-solver` is also still in
+		// flux, so the absolute count drifts as it improves. The per-test `expected_failures`
+		// list below is the precise regression guard; this count band only catches gross moves.
+		acceptable_delta := 15
 		mut found_acceptable := false
 		for sline in summary_lines {
 			count_str := sline.all_after('files: ').all_before(' failed')
 			actual_count := count_str.int()
 			expected_str := actual_expected_summary.all_after('files: ').all_before(' failed')
 			expected_count := expected_str.int()
-			if actual_count > 0 && expected_count > 0 && actual_count >= expected_count - 2
-				&& actual_count <= expected_count + 2 {
+			if actual_count > 0 && expected_count > 0
+				&& actual_count >= expected_count - acceptable_delta
+				&& actual_count <= expected_count + acceptable_delta {
 				found_acceptable = true
 				break
 			}