Fix preferLazyMap rewrites that were not behavior-preserving

[jparise]

Summary

Follow-up to #2656. Enabling preferLazyMap across a ~50k-file first-party codebase surfaced three ways the rewrite was not behavior-preserving. This tightens the rule so the same sweep now builds clean.

Making a map lazy changes more than whether an intermediate array is allocated:

	Cause	Symptom
1	Closure becomes escaping	compile error on implicit self in a reference type
2	joined() resolves to a different overload	silent — String becomes a lazy sequence
3	.lazy requires Sequence	compile error on other map-providing types

1. Implicit self in the closure

lazy.map stores its transform, so its closure is escaping while eager map's is not. Inside a reference type that difference is load-bearing:

final class Generator {
  func render(_ value: Int) -> String { "\(value)" }
  func eager() -> String { values.map { render($0) }.joined(separator: ",") }
  // error: call to method 'render' in closure requires explicit use of 'self'
  func lazyOne() -> String { values.lazy.map { render($0) }.joined(separator: ",") }
}

Whether a bare name is a member of self, a global function, or a type isn't resolvable from tokens, so the rule now rewrites only when the closure body references nothing but its own arguments. Member accesses through a ., argument labels, keywords and literals still qualify, so the projections this rule targets ($0.foo, $0.a.b, $0.name(x: true)) are unaffected. Deliberately conservative: hypot($0.x, $0.y) is skipped even though it captures no self, being indistinguishable from a member reference here.

2. joined() with no separator

On a lazy sequence this resolves to the sequence-flattening overload instead of the StringProtocol one:

parts.map { $0 + "!" }.joined()       // String
parts.lazy.map { $0 + "!" }.joined()  // LazySequence<FlattenSequence<...>>

This is the one I'd flag hardest, because it doesn't fail at the rewritten line. In a string interpolation it emits the sequence's description, which corrupted the generated output of a macro that string-builds source. joined now requires a separator argument; joined(separator:) returns String either way.

3. Identity maps

map { $0 } transforms nothing, so laziness saves no work while lazy still has to exist on the receiver. map is defined on plenty of non-Sequence types (Optional, Result, publishers, custom iterators), so these are now left alone: no upside, and it removes a way for the rewrite to stop compiling.

A caveat worth naming

(3) only removes the instances we hit. In general a token-based rule cannot know that the receiver of .map is a Sequence, so a rewrite can still fail to compile on a non-Sequence receiver. That seems acceptable for a disabled-by-default rule, but I'm happy to document it in the rule's help text, or narrow the rule further.

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 95.46%. Comparing base (df2c5bd) to head (bbb9c2f).
⚠️ Report is 1 commits behind head on develop.

Additional details and impacted files

@@             Coverage Diff             @@
##           develop    #2661      +/-   ##
===========================================
+ Coverage    95.45%   95.46%   +0.01%     
===========================================
  Files          178      178              
  Lines        27137    27186      +49     
===========================================
+ Hits         25904    25954      +50     
+ Misses        1233     1232       -1     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.