block scanning should use block acceleration features of the TCT

[TalDerei]

clients stream compact blocks and construct a filtered instance of the SCT. Currently, we're trial-decrypting every encrypted payload for every block retrieved from the full node. However, our wasm view server implementation doesn't yet take advantage of the TCT acceleration features detailed in Penumbra issue #842. In that context, we can use the fact that penumbra commits the intermediate root hash of every block, and client synchronization can stream the root hashes of each block without needing to know the individual commitments. This approach would reduce the number of Merkle hashing operations needed to insert a block into the SCT.

our scan_block implementation was built using mock_client as a template. Instead, we should employ the TCT's API, specifically the insert_block and insert_epoch methods, to accelerate block syncing.

we've essentially built this highly optimized merkle tree (Tierd Commitment Tree) designed for efficient client sync, but we're not taking advantage of it's fundamental properties.

[hdevalence]

the relevant code in the rust view server is here: https://github.com/penumbra-zone/penumbra/blob/main/crates/view/src/sync.rs#L111-L117

the optimization is: if the result of scanning the block is that there were no decryptions, use insert_block.

there's no need to use the epoch-level insertion features at this time as that is more complicated to employ (scanning goes block by block, so doing epoch-level insertion would require buffering an entire epoch, which is also the reason it's not used in the native view server implementation).

[hdevalence]

this optimization isn't completely trivial to port to the wasm view server, because it inlines together the trial decryption and the SCT insertions into one sequence of operations:

https://github.com/penumbra-zone/web/blob/main/packages/wasm/crate/src/view_server.rs#L123-L130

instead, these operations can be cleanly separated by using in-memory advice, as in the native code: https://github.com/penumbra-zone/penumbra/blob/main/crates/view/src/sync.rs#L86-L109 : first, build a lookup table of successful decryptions (the "advice"), then use it when processing each note payload. that way, it's easy to write code that skips over an empty block, as all the trial decryption is done up-front.

the native code's behavior of always asking the storage for advice is not necessary and probably undesirable to replicate, since it means waiting for an extra read regardless of whether there are any rolled-up payloads in the compact block. most blocks don't have these, so the wasm code's current behavior of only fetching from storage when there is known to be something to fetch seems good to preserve.

[hdevalence]

Added some code that ports the native rust code's advice mechanism to the wasm crate in #1716 but it needs testing to check that it doesn't mess up the SCT synchronization