Add map and map_with_key Methods to Map

[Asterless]

Summary

Based on #1890
This PR adds two new methods to Map in builtin/linked_hash_map.mbt:

• map(f: (V) -> V2) -> Map[K, V2]
  Applies a function to each value in the map and returns a new map with the same keys and transformed values.

• map_with_key(f: (K, V) -> V2) -> Map[K, V2]
  Applies a function to each key-value pair and returns a new map with the same keys and transformed values.

Implementation Details

• Both methods preserve the insertion order of keys.
• map is implemented by calling map_with_key and ignoring the key.
• If the map is empty, a new empty map is returned.
• The new map is pre-allocated with the same size as the original for efficiency.

Example Usage

let m = {1: 10, 2: 20}
let m2 = m.map(fn(v) { v * 2 }) // {1: 20, 2: 40}
let m3 = m.map_with_key(fn(k, v) { k + v }) // {1: 11, 2: 22}

Impact

• Backward compatible; does not affect existing APIs or behavior.
• Only adds new functionality to Map.

[peter-jerry-ye-code-review]

Pre-allocation optimization missing for partition method

Category
Performance
Code Snippet
let m1 = Map::new(capacity=self.size)
let m2 = Map::new(capacity=self.size)
Recommendation
Consider using a smaller initial capacity for both maps, since the final size of each will likely be less than the original. Something like: let m1 = Map::new(capacity=self.size / 2)
Reasoning
While pre-allocating with the full size works, it's likely wasteful since after partitioning each resulting map will be smaller than the original. This leads to unnecessary memory allocation.

Fold method documentation could be more descriptive

Category
Maintainability
Code Snippet
/// Folds the map from an initial value by applying a function to each key-value pair and the accumulator.
/// The order of folding is not guaranteed.
Recommendation
Add examples in the documentation and clarify the accumulator type requirements:

/// Folds the map from an initial value by applying a function to each key-value pair and the accumulator.
/// The order of folding is not guaranteed.
/// Example:
/// ```
/// let m = {1: 10, 2: 20}
/// let sum = m.fold(0, fn(acc, k, v) { acc + v }) // 30
/// ```
**Reasoning**
More detailed documentation with examples helps users understand the purpose and usage of the method better, especially for functional programming concepts like fold.

</details>
<details>

<summary> Implicit return in for loop could be made explicit </summary>

**Category**
Correctness
**Code Snippet**
for e in self {
  acc = f(acc, e.0, e.1)
}
acc
**Recommendation**
Consider making the mutation and return more explicit:
```moonbit
let mut acc = init
for e in self {
  acc = f(acc, e.0, e.1)
}
return acc

Reasoning
While both versions are functionally equivalent, making the mutation and return explicit improves code readability and makes the control flow more obvious.

[coveralls]

Pull Request Test Coverage Report for Build 7130

Details

• 0 of 20 (0.0%) changed or added relevant lines in 1 file are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage decreased (-0.2%) to 92.933%

---

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
builtin/linked_hash_map.mbt	0	20	0.0%

Totals
Change from base Build 7124:	-0.2%
Covered Lines:	8574
Relevant Lines:	9226

---

💛 - Coveralls

[FlyCloudC]

There are many hash calculations that can be avoided here.

[peter-jerry-ye]

Please focus on the functionalities that you described in the introduction; do not add too many stuff in one PR.

[Asterless]

ok👍

[peter-jerry-ye]

There are too many unrelated modifications. I'm closing this PR for the new one.

[peter-jerry-ye]

Continue in #2228 #2229