chore(doc strings): Make rustc v1.83.0 linter happy

All complaints were about this rule:
https://rust-lang.github.io/rust-clippy/master/index.html#/too_long_first_doc_paragraph

Author: Sword-Smith

tasm-lib/src/array/horner_evaluation.rs

@@ -5,6 +5,8 @@ use crate::data_type::ArrayType;
 use crate::data_type::DataType;
 use crate::traits::basic_snippet::BasicSnippet;
 
+/// Evaluate a polynomial in a point using the Horner method.
+///
 /// HornerEvaluation takes an array of coefficients (representing a polynomial)
 /// and a scalar (representing an indeterminate) and computes the value of the
 /// polynomial in that point. It can be used for univariate batching, whereby

tasm-lib/src/hashing/merkle_verify.rs

@@ -3,6 +3,8 @@ use crate::library::Library;
 use crate::traits::basic_snippet::BasicSnippet;
 use triton_vm::prelude::*;
 
+/// Verify membership in a Merkle tree.
+///
 /// MerkleVerify -- verify that a leaf lives in a Merkle tree,
 /// given the root, leaf index, and leaf. The authentication path
 /// is non-deterministically divined. This algorithm asserts

tasm-lib/src/hashing/sponge_hasher/squeeze.rs

@@ -7,6 +7,8 @@ use crate::library::Library;
 use crate::memory::dyn_malloc::DynMalloc;
 use crate::traits::basic_snippet::BasicSnippet;
 
+/// Squeeze the sponge and return an array of `[RATE]` elements
+///
 /// Snippet that emulates the Tip5 implementation of twenty-first's
 /// `sponge_hasher` trait function `squeeze`. You probably don't want to use
 /// this snippet for whatever cryptography you're doing and instead use the

tasm-lib/src/hashing/squeeze_repeatedly_static_number.rs

@@ -4,6 +4,8 @@ use triton_vm::twenty_first::math::tip5::RATE;
 use crate::data_type::DataType;
 use crate::traits::basic_snippet::BasicSnippet;
 
+/// Squeeze the sponge a statically-known number of times.
+///
 /// Squeeze the sponge `num_squeezes` times, storing all the produced pseudorandom `BFieldElement`s
 /// contiguously in memory. It is the caller's responsibility to allocate enough memory.
 /// Number of squeezes must be statically known.

tasm-lib/src/lib.rs

@@ -282,6 +282,8 @@ pub fn execute_with_terminal_state(
     }
 }
 
+/// Run prover on the program, with stack-initialization converted to code.
+///
 /// Run the prover on the program. If `init_stack` is provided, the prover is run on a program
 /// with the code to setup the stack prepended, since the prover will always fail if the stack
 /// is not initialized to the minimal height. The first `NUM_OP_STACK_REGISTERS` of `init_stack`

tasm-lib/src/list/multiset_equality_digests.rs

@@ -6,8 +6,9 @@ use crate::library::Library;
 use crate::list::length::Length;
 use crate::traits::basic_snippet::BasicSnippet;
 
-/// Determine whether two lists are equal up to permutation. The
-/// lists are given as lists of digests. This function uses hashing
+/// Determine whether two lists are equal up to permutation.
+///
+/// The lists are given as lists of digests. This function uses hashing
 /// to compute a challenge indeterminate, and then computes a running
 /// products for both lists. In the future, the implementation of
 /// function may be replaced by one that uses Triton VM's native

tasm-lib/src/mmr/verify_mmr_successor.rs

@@ -22,6 +22,8 @@ use crate::{
     Digest,
 };
 
+/// Verify that one MMR is a successor to another.
+///
 /// Verify a the scucessorship relation between two MMRs. A `MmrSuccessorProof`
 /// is necessary to demonstrate this relation, but it is not a *stack* argument
 /// because this algorithm obtains the relevant info (authentication paths) from

tasm-lib/src/traits/algorithm.rs

@@ -17,6 +17,8 @@ use crate::VmHasher;
 use super::basic_snippet::BasicSnippet;
 use super::rust_shadow::RustShadow;
 
+/// An Algorithm can modify memory and take ND_input.
+///
 /// An Algorithm is a piece of tasm code that can modify memory even at addresses below
 /// the dynamic memory allocator, and can take nondeterministic input. It cannot read from
 /// standard in or write to standard out.

tasm-lib/src/traits/function.rs

@@ -16,6 +16,8 @@ use crate::VmHasher;
 use super::basic_snippet::BasicSnippet;
 use super::rust_shadow::RustShadow;
 
+/// A function can modify stack and extend memory.
+///
 /// A Function is a piece of tasm code that can modify the top of the stack, and can read
 /// and even extend memory. Specifically: any memory writes have to happen to addresses
 /// larger than the dynamic memory allocator and the dynamic memory allocator value has to

tasm-lib/src/traits/procedure.rs

@@ -22,6 +22,8 @@ use crate::traits::rust_shadow::RustShadow;
 use crate::InitVmState;
 use crate::VmHasher;
 
+/// A trait that can modify all parts of the VM state.
+///
 /// A Procedure is a piece of tasm code that can do almost anything: modify stack, read
 /// from and write to memory, take in nondeterminism, and read and write from standard
 /// input/output. What it cannot do is stand alone. In other words, it is still wrapped