How can I vectorize the computations for a first-order recursive filter?
Assuming that you perform vector operations $M$ elements at a time, you can unroll the difference equation by a factor of $M$ pretty easily for the simple single-pole filter. Assume that you have already calculated all outputs up to $y[n]$. Then, you can calculate the subsequent ones as follows:
$$
\begin{align}
y[n+1] &amp;= (1-a)y[n] + ax[n+1] \\
y[n+2] &amp;= (1-a)y[n+1] + ax[n+2] \\
&amp;= (1-a)((1-a)y[n] + ax[n+1]) + ax[n+2] \\
&amp;= (1-a)^2y[n] + a(1-a)x[n+1] + ax[n+2] \\
&amp;\vdots
\end{align}
$$

In general, you can write $y[n+k]$ as:

$$
y[n+k] = (1-a)^ky[n] + \sum_{i=1}^k a(1-a)^{k-i}x[n+i]
$$

For each sample index $n+k$, this looks like an FIR filter with $k+1$ taps: one tap multiplies the last filter output $y[n]$, and the other $k$ taps multiply the filter inputs $x[n+1], \ldots , x[n+k]$. The nice thing is that the coefficients used for all of these taps can be precalculated, allowing you to unroll the recursive filter into $M$ $M+1$-tap parallel non-recursive filters (these filters compute the output samples $y[n+1], \ldots , y[n+M]$), updating the feedback term every $M$ output samples. So, given an initial condition $y[n]$ (which is assumed to be the last output calculated on the previous 
vectorized iteration), you can calculate the next $M$ outputs in parallel.

There are some caveats to this approach: 


If $M$ becomes large, then you end up multiplying a bunch of numbers together in order to get the effective FIR coefficients for the unrolled filters. Depending upon your number format and the value of $a$, this could have numerical precision implications. 
Also, you don't get an $M$-fold speedup with this approach: you end up calculating $y[n+k]$ with what amounts to a $k$-tap FIR filter. Although you're calculating $M$ outputs in parallel, the fact that you have to do $k$ multiply-accumulate (MAC) operations instead of the simple first-order recursive implementation diminishes some of the benefit to vectorization. The non-vectorized approach uses 2 MACs per output, so you need $2M$ operations to calculate $M$ outputs. The vectorized scheme computes the $M$ outputs at once, requiring $M+1$ MACs in the process. So, the reduction in operations can be expressed as a function of $M$ as:

$$
    R = \frac{M+1}{2M} = \frac{1}{2}\left(1 + \frac{1}{M}\right)
    $$

So, even with $M$ very large, you can get a maximum of a 50% reduction in the amount of computations using this method. For the common values of $M=4$ and $M=8$, the reduction is 37.5% and 43.75%, respectively. However, in addition to pure reduction in the number of operations, you may gain additional performance benefits due to the different memory access pattern employed by the unrolled approach; for the simpler implementation, you may run into delays due to the dependency of each output sample $y[n]$ on the previous sample $y[n-1]$. This effect is obviously very platform-dependent.