Collision resistance of partial SHA-256 hashes XOR'ed My hashing algorithm computes the SHA-256 for each of 12 input strings and XORs them to get the final hash.

Is there a risk of an attacker being able to forge 2 sets of inputs that yield the same final hash?

To avoid trivial attacks by feeding in the same input twice and make this scheme order-dependent, I prepend each input with its index (binary 0 to 11).

For the case of 256 inputs there is an easy attack (as each hash can be used to control a single output bit using matrix calculus), this makes me wonder whether there are similar attacks for just 12 inputs. 

I'm aware that there are more secure alternatives such as Merkle trees but I really need maximum performance especially for when just a single input is modified.
Let tne hashlength be $d$. With $k=12,$ this is the $k-$ XOR problem. Fix $k.$ If the vectors are randomly generated and form a list of size roughly at least $2^{d/k},$ there exists a solution with constant probability bounded away from zero. This is because a list of size $M$ contains $$F:=\binom{M}{k}$$ subsets of size $k,$ and thus as 
$\{x_1,\ldots,x_k\}$ ranges over these subsets the function $f(x_1,\ldots,x_k):=x_1\oplus \cdots \oplus x_k$ ranges over $\{0,1\}^d.$

This is a $F$ balls into $2^d$ bins problem and if $F\geq 2^d,$ the probability that $f$ misses the bin corresponding to your given hash value 
$h_0 \in \{0,1\}^d$ is roughly $e^{-1}\approx 0.37.$ Taking $M=\Omega(k 2^{d/k})$ is enough here. However, finding the solution is computationally more expensive.

Wagner (see here ) has a recursive binary tree based algorithm for the $k-$ XOR problem $$x_1\oplus \cdots \oplus x_k=0 \qquad (1)$$ with $k=2^m,$ with time and memory complexity essentially 
$$O(k 2^{d/(1+m)}).$$ The zero vector on the right hand side of (1) can be replaced by any constant vector.

Let $x_9,\ldots,x_{12},$ be arbitrary and use Wagner with $k=8$ to solve the $8-$ XOR problem

$$x_1\oplus \cdots \oplus x_8=c,$$
with $c=x_9\oplus x_{10} \oplus x_{11} \oplus x_{12}\oplus h_0.$ This can be done with complexity 
$$O(k 2^{d/(m+1)})=O(8 \times 2^{256/4})=O(2^{67}).$$