Avoid double memory allocation when encoding/decoding state witness

[pugachAG]

Currently we allocate memory for borsh bytes before compressing state witness.
This can be avoided with streaming, see this comment
The implementation would look something like this:

        let mut buf = Vec::new().writer();
        let mut encoder = zstd::stream::Encoder::new(&mut buf, STATE_WITNESS_COMPRESSION_LEVEL)?;
        borsh::to_writer(&mut encoder, witness)?;
        encoder.finish()?;

The only missing bit is counting bytes in borsh representation of state witness. This can be implemented with wrapper on top of Write to count bytes and then write it downstream. Maybe bytes crate already has something like this.

Decoding is similar, see this comment.

[nagisa]

A sketch of an implementation:

struct LimitedWrite<W: Write> {
    limit: usize,
    written: usize,
    inner: W,
}

impl<W: Write> Write for LimitedWrite {
    fn write(&mut self, mut buf: &[u8]) -> io::Result<usize> {
        let mut to_write = buf.len();
        if self.written.saturating_add(to_write) >= self.limit {
            to_write = self.limit - self.written;
        }
        let written = self.inner.write(&buf[..to_write])?;
        self.written = self.written.saturating_add(written);
        Ok(written)
    }
}

[tayfunelmas]

Looks like a good starting task and already has the solution, so claiming it :P

[tayfunelmas]

Addressed in #11232.