copy_tv() and clear_tv() can be improved for scalar values - #20787

vim9script
# Scalar-heavy workload (the fast-path's best case): a Sieve of Eratosthenes
# over a reused list<bool>.  Each pass resets, sieves and counts purely through
# list-index reads and writes of scalar typvals plus arithmetic and
# comparisons; the list is allocated once (outside the loop) and no builtin or
# string work is in the hot path, so the inline copy_tv()/clear_tv() win is
# what moves the number.
const OUT = exists('g:BENCH_OUT') ? g:BENCH_OUT : '/tmp/scalarbench.txt'
def CountPrimes(sieve: list<bool>): number
  var n = len(sieve)
  var k = 0
  while k < n
    sieve[k] = true			# reset: scalar store (clear_tv + copy_tv)
    k += 1
  endwhile
  var i = 2
  while i * i < n
    if sieve[i]
      var j = i * i
      while j < n
        sieve[j] = false		# mark composite: scalar store
        j += i
      endwhile
    endif
    i += 1
  endwhile
  var count = 0
  i = 2
  while i < n
    if sieve[i]				# read scalar onto the stack
      count += 1
    endif
    i += 1
  endwhile
  return count
enddef
def Main()
  var iter = 200000
  if exists('g:ITER')
    iter = g:ITER
  endif
  var sieve: list<bool> = []
  for _ in range(2000)
    sieve->add(true)			# allocate once, outside the timed loop
  endfor
  var t = reltime()
  var acc = 0
  for _ in range(iter)
    acc += CountPrimes(sieve)		# pi(2000) = 303, so check = iter * 303
  endfor
  writefile([printf('ITER=%d elapsed=%.3fs check=%d',
    iter, reltimefloat(reltime(t)), acc)], OUT)
enddef
try
  Main()
catch
  writefile(['EXC: ' .. v:exception .. ' @ ' .. v:throwpoint], OUT)
endtry
qall!

vim9script
# Non-scalar-heavy counterpart to scalarbench.vim: hammers copy_tv()/clear_tv()
# on strings, lists and dicts (deepcopy / slice / extend / remove / scope exit),
# so any regression from the scalar fast-path's extra branch on non-scalar
# values would show here.
const OUT = exists('g:BENCH_OUT') ? g:BENCH_OUT : '/tmp/containerbench.txt'
def Build(n: number): list<dict<any>>
  var out: list<dict<any>> = []
  for i in range(n)
    out->add({
      name: 'item_' .. i,
      tag: 'tag_' .. (i % 7),
      vals: [string(i), string(i * 2), string(i * 3)],
      meta: {a: 'x' .. i, b: 'y' .. i},
    })
  endfor
  return out
enddef
def Churn(base: list<dict<any>>): number
  var total = 0
  var c = deepcopy(base)		# copy_tv over every nested string/list/dict
  var s = c[0 : len(c) / 2]		# list slice: copy_tv of dict refs
  c->extend(s)
  for d in c
    total += len(d.name) + len(d.vals)
    for v in d.vals
      total += str2nr(v)		# fold the copied value content, not just its length
    endfor
    if has_key(d, 'meta')
      total += len(d.meta) + len(d.meta.a) + len(d.meta.b)
    endif
  endfor
  while len(c) > 0
    remove(c, 0)			# clear_tv of non-scalar items
  endwhile
  return total
enddef
def Main()
  var iter = 20000
  if exists('g:ITER')
    iter = g:ITER
  endif
  var base = Build(32)
  var t = reltime()
  var acc = 0
  for _ in range(iter)
    acc += Churn(base)
  endfor
  writefile([printf('ITER=%d elapsed=%.3fs check=%d',
    iter, reltimefloat(reltime(t)), acc)], OUT)
enddef
try
  Main()
catch
  writefile(['EXC: ' .. v:exception .. ' @ ' .. v:throwpoint], OUT)
endtry
qall!