perf(codegen): reduce allocations in SourcemapBuilder (#13677)

Follow-on after #13670.

That PR made 2 changes:

1. Pre-allocating capacity in `columns` `Vec`.
2. `mem::take`-ing `columns` for each line, rather than re-using it.

In my opinion, the 1st change is good, but the 2nd is not.

Revert the usage of `mem::take`, and add a comment explaining why the `.clone()` is not as bad as it looks!

Before this PR: `columns` will likely have spare capacity, so `mem::take(&mut columns).into_boxed_slice()` will perform a reallocation to drop the excess capacity, and then `columns.reserve(256)` performs a 2nd allocation.

Approach after this PR:

1. `columns.clone().into_boxed_slice()` performs 1 allocation, and copies the data from `columns` into this new allocation. `columns.clear()` does not perform any reallocation, and is a very cheap operation.

2. `columns` `Vec` is reused over and over, and will grow adaptively depending on how heavy the file's use of unicode chars is, rather than always going back to estimated max capacity of 256.

Benchmarks show a very small positive difference.

Author: overlookmotel

crates/oxc_codegen/src/sourcemap_builder.rs

@@ -389,14 +389,18 @@ impl<'a> SourcemapBuilder<'a> {
                             // `chunk_byte_offset` is now the offset of *end* of the line break.
                             line_byte_offset += chunk_byte_offset;
 
-                            // Record column offsets
-                            // Use mem::take to avoid clone - moves columns out and replaces with empty Vec
+                            // Record column offsets.
+                            // `columns.clone().into_boxed_slice()` does perform an allocation,
+                            // but only one - `Vec::clone` produces a `Vec` with `capacity == len`,
+                            // so `Vec::into_boxed_slice` just drops the `capacity` field,
+                            // and does not need to reallocate again.
+                            // `columns` is reused for next line, and will grow adaptively depending on
+                            // how heavily the file uses unicode chars.
                             column_offsets.push(ColumnOffsets {
                                 byte_offset_to_first: byte_offset_from_line_start,
-                                columns: std::mem::take(&mut columns).into_boxed_slice(),
+                                columns: columns.clone().into_boxed_slice(),
                             });
-                            // Reserve capacity for next line to avoid reallocation
-                            columns.reserve(256);
+                            columns.clear();
 
                             // Revert back to outer loop for next line
                             continue 'lines;