Add `std::move` optimization to last use of matrix and array like objects

Given a model like below where we have a large N*N parameter matrix, it would be useful to be able to tell the stan math functions about the last place the matrix is used.

parameters {
  matrix[N, M] big_mat;
  matrix[M] big_vec;
  vector[N] sigma;
}

model {
 // Do other things here 
 // ...
 // last use of each parameter
 y ~ normal(big_data * big_mat * big_vec, sigma);
}

In the c++ it would be nice if we could use dependency analysis to detect the last time a matrix / array like object is used and add additional metadata flagging that. Then the C++ can write the following

lp_accum__.add(
  normal_lpdf(
    multiply(multiply(big_data, std::move(big_mat)), std::move(big_vec)),
    std::move(sigma)
  )
);

Internally, stan math can then store that memory instead of copying it over to the arena. The arena_matrix type has a special rvalue overload where it does not actually copy the memory of objects over to the stack allocator, but just stores the data in a place that it can be deleted once the user calls recover_memory(). So in most cases this optimization would save space on the stack allocator and remove a copy.

The issue names no implementation files or tests; start with the Stan model and the generated C++ example using std::move. Done means dependency analysis identifies last uses of matrix- and array-like objects and emits the move metadata so Stan Math can avoid copying their memory into the arena.