Estimation
Looking at
$$
2^n = 10^x \iff x = n \log_{10} 2 = \frac{\ln 2}{\ln 10} n \approx 0.3 \, n
$$
$(2^n)_2$ has $n+1$ digits, $(2^n)_{10}$ has about $n/3$ digits.
$10$ new digits in base $2$ ($2^{10} = 1024$) give about $3$ new digits in base 10.
My gut feeling is that with more and more digits, more and more digits have the chance to be non-zero, which will lead to a growth of $S((2^n)_{10})$ in the long run.
Note: A counter example to this idea is $S((2^n)_2) = 1 = \mbox{const.}$, where the division is perfect.
Calculation of the base 10 digits
For the $m$ digits $d_k$ of $(2^n)_{10}$ we have
$$
2^n = \sum_{k=0}^{m-1} d_k \, 10^k
$$
We start with $n = 0$:
$$
m^{(0)} = 1 \quad
d_0^{(0)} = 1
$$
As $n$ increases we have
$$
(2^{n+1})_{10} =
(2^{n} + 2^{n})_{10}
$$
so the digits can be calculated by addition with carry,
for the $k$-th digit we have
$$
d_k^{(n+1)} =
\left( 2 \, d_k^{(n)} + c_{k-1}^{(n+1)} \right) \bmod 10 \quad (*) \\
c_k^{(n+1)} =
\left\lfloor
\left( 2 \, d_k^{(n)} + c_{k-1}^{(n+1)} \right) / 10
\right\rfloor
$$
where $c_k$ is the carry value, in this case $c_k \in \mathbb{B} = \{0,1\}$. We set $c_{-1} = 0$ and note that a set carry bit $c_{m}^{(n+1)}$ will trigger the creation of a new digit $d_{m}^{(n+1)} = 1$ and increase $m$: $m^{(n+1)} = m^{(n)} + 1$.
Equation $(*)$ is quite similar to a linear congruential generator
$$
X_{n+1} = (a X_{n} + c) \bmod m
$$
which is used to generate pseudo random numbers. The difference is a variable $c$ in equation $(*)$ versus the constant $c$ in the LCG. Also $a=2$ and $m=10$ might not be the best choices for a good PRNG.
This might justify the assumption of random digits, if one dives deeper into LCG properties.
Development of the digits $d_k^{(n)}$
$$
\begin{array}{c|cccccccccc}
c_{k+1} \, d_k^{(n+1)} & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & = d_k^{(n)} \\
\hline
c_k = 0 & 0\, 0 & 0\, 2 & 0\, 4 & 0\, 6 & 0\, 8 & 1\, 0 & 1\, 2 & 1\, 4 & 1\, 6 & 1\, 8 \\
\hline
c_k = 1 & 0\, 1 & 0\, 3 & 0\, 5 & 0\, 7 & 0\, 9 & 1\, 1 & 1\, 3 & 1\, 5 & 1\, 7 & 1\, 9 \\
\end{array}
$$
The computation rules are simple but they gives raise to a complex behaviour.
For the last digit $d_0$ we get a cycle of length $4$: 4,8,6,2
c 0<0>0 0 0<0> ..
d 1<2>4 8 6<2>
d+ 2 4 8 6 2 4 ..
----------
c+ 0 0 0 1 1 0
For the next digit $d_1$ we get a cycle of length $20$:
d_1:
c 0 0 0<1>1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0<1>1 0 0 ..
d 0 0 0<0>1 3 6 2 5 1 2 4 9 9 8 6 3 7 4 8 7 5 0<0>1 3 6
d+ 0 0 0 1 3 6 2 5 1 2 4 9 9 8 6 3 7 4 8 7 5 0 0 1 3 6 2 ..
---------------------------------------
c+ 0 0 0 0 0 0 1 0 1 0 0 0 1 1 1 1 0 1 0 1 1 1 0 0 0 0 1
For $d_2$ one gets this development:
d_2:
c 0 0 0 0 0 0<1>0 1 0..
d 0 0 0 0 0 0<0>1 2 5
d+ 0 0 0 0 0 0 1 2 5 0
-------..
c+ 0 0 0 0 0 0 0 0 0 1..
000000
0125000137501251362487498
6251374987512486363624999
9874999862498748637512501
3748625012487513636375000
0125000..
It features a cycle of length $100$.
So a newly introduced digit starts as a $1$ and seems to go (after some iterations) into a cycle. This is influenced by the carry bit sequence of the digit before.
Development of the digit sum
The digit sum
$$
S((2^{(n)})_{10}) = \sum_{i=1}^9 f_i^{(n)} \, i
$$
depends on the counts $f_i^{(n)}$ of the non-zero digits.
A rough estimation is that it will be the length of the string representation times the average digit $4.5$, including that this will increase, because the string length has to grow with increasing $n$.
However I have no justification for this, except some calculated values.