Why the difference when returning the values?

I think that all these doubts can be clarified at the same time, explaining well how recursion works. So, let's explain the basics:

A recursive function is one that calls itself. Let's leave indirect recursion aside (function A calls function B, which calls back to A) for simplicity.

A recursive function must have 2 well differentiated cases:

• The base case, which is the trivial case where recursion is not used. For example, if we want to sum all the elements of an array, the base case is when the array is empty. In that case we return 0 and the execution ends there.

• The recursive case, which is the non-trivial case. In this case, what is done is to break down the problem to be solved into smaller problems. Once the smaller problems have been solved, the original problem is solved with the union of all the solutions, either by adding, concatenating, multiplying... etc.

Once we understand the cases, we can move on to designing a solution to our problem. Take for example the case of adding all the elements of an array:

var ejemplo=[1,2,3,4,5,6,7,8,9,10];

The base case would be when we want to add the elements of an empty array:

var ejemplo2=[];

In that case the resulting value is zero, so let's put that in our function:

function sumaArray(array) {
  //caso base
  if (array.length===0) {
    return 0;
  }
  //caso recursivo
  //... por definir
}

So we have the recursive case: If we have an array with N elements where N is greater than 0, let's take the first element. So we have on the one hand an element E and on the other hand an array with N-1 elements. We just reduced the problem, going from N to N-1. Therefore, the result would be adding the E plus the sum of the rest of the elements. Let's add the recursive case to our function and test it:

function sumaArray(array) {
  //caso base
  if (array.length===0) {
  console.log('sumArray() da 0');
    return 0;
  }
  const e=array[0];
  const arrayConUnElementoMenos=array.slice(1); //devuelve el array menos el primer elemento
  console.log(`Devuelvo la suma de ${e} y el resultado de sumArray(${arrayConUnElementoMenos})`);
  return e + sumaArray(arrayConUnElementoMenos);
}

console.log(sumaArray([1,2,3,4]));

If, as in your first example, instead of returning e + sumaArray(arrayConUnElementoMenos);we had simply returned sumaArray(arrayConUnElementoMenos);, we would not be accumulating anything, we would simply return the base case (0) forgetting the intermediate results.

Perhaps your second example is complicated to understand because of the notation used:

const [first, ...rest] = nums;

This line is equivalent to what I have put in my example:

const first=nums[0]; //primer elemento del array nums
const rest=nums.slice(1); // resto de elementos del array

And your last example fails in that you are adding an array to a number. Javascript, when you try to add data types that are not compatible, what it does is transform both types to text (strings) and concatenate them:

var array = [2,4,6,8];
var numero= 0;
var texto= 'hola';
var objeto={};

console.log(array + numero);
console.log(array+texto);
console.log(objeto + array);

The first case returns 0 because the last call to the recursive function returns 0 and the rest of the calls return the result as is:

return multiplo(arr);  //devuelve 0
return multiplo(arr);  //devuelve 0
return multiplo(arr);  //devuelve 0
return multiplo(arr);  //devuelve 0
.....
return multiplo(arr);  //devuelve 0
return multiplo(arr);  //devuelve 0
return 0;

In the second case, the last call also returns 0, but the previous ones add a value to the result before returning it:

return 0 + sum(rest); // devuelve 45
return 1 + sum(rest); // devuelve 45
return 2 + sum(rest); // devuelve 44
return 3 + sum(rest); // devuelve 42
return 4 + sum(rest); // devuelve 39
return 5 + sum(rest); // devuelve 35
return 6 + sum(rest); // devuelve 30
return 7 + sum(rest); // devuelve 24
return 8 + sum(rest); // devuelve 17
return 9 + sum(rest); // devuelve 9
return 0;

This is because the two recursive functions work differently:

The first function simply returns the result of the recursive function.

return multiplos(arr); 

That is, it returns the last value, that is 0, as it effectively turns out:

The second function returns the first element plus the result of the recursive function, that's why it gives 45: doing a debug this would be what would happen

console.log(sum([0,1,2]))

in the first instance the size of the array is 3, then it returns

0 + sum([1,2])  // 

now the array is of length 2, so it returns

1 + sum([2])

now the array is of length 1, so it returns

2 + sum([])

now if it returns 0, that is, adding the responses

 2 + sum([]) = 2  // 2 + 0 
 1 + sum([2]) = 3 // 1 + el resultado anterior es decir 2
 0 + sum([1,2]) = 3 // 0 + el resultado anterior es decir 3

then , the result will be 3, by the sum it accumulates.

for it to return 0, your function should be like this

 function sum(nums) {
   if (nums.length === 0) {
      console.log("Sí llegé a 0");
      return 0;
    } else {
       const [first, ...rest] = nums;
       return sum(rest);
    }
 }
console.log(sum([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

Why don't you implement the function like this?

function sum(nums) {
   var i = 0;
   for (var j = 0; j < nums.length; j++) { i += nums[j]; }
   return i;
 }
console.log(sum([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

It makes more sense than using recursion.