Bom, fiz o teste comparando os algoritmos com e sem desestruturação, e também com e sem BigInt:

var Benchmark = require('benchmark');
var suite = new Benchmark.Suite;

suite
.add('desestruturação', function () {
    const n = 1000;
    let a = 0, b = 1;
    for (let i = 0; i < n; i++) {
      [a, b] = [b, a + b];
    }
})
.add('sem desestruturação', function () {
    const n = 1000;
    let a = 0, b = 1;
    for (let i = 0; i < n; i++) {
        let tmp = a;
        a = b;
        b += tmp;
    }
})
.add('desestruturação BigInt', function () {
    const n = 1000000n;
    let a = 0n, b = 1n;
    for (let i = 0n; i < n; i++) {
      [a, b] = [b, a + b];
    }
})
.add('sem desestruturação BigInt', function () {
    const n = 1000000n;
    let a = 0n, b = 1n;
    for (let i = 0n; i < n; i++) {
        let tmp = a;
        a = b;
        b += tmp;
    }
})
.on('complete', function () {
    console.log('Fastest is ' + this.filter('fastest').map('name'));
})
.on('cycle', function (event) {
    console.log(String(event.target));
})
.run({
    'async': true
});

Testei só no Linux, porque no Mac já vimos que BigInt fica bem mais lento usando o Bun.

Resultados (em operações por segundo, ou seja, quanto mais, melhor):

Teste	Node	Bun
desestruturação	236.387	3.920.325
sem desestruturação	1.085.075	3.897.458
desestruturação BigInt	0,11	0,11
sem desestruturação BigInt	0,12	0,11

Ou seja, parece que a implementação da desestruturação no Bun é mais rápida que no Node. Basta ver que sem desestruturação e sem BigInt, o Node pulou de 236 mil para 1 milhão de operações por segundo (e mesmo assim não chegou perto do Bun).

Mas quando BigInt é usado, a diferença já não foi tão grande. Imagino que neste caso o overhead dos cálculos parece ter um impacto maior que a desestruturação.