[sui-verifier] Move helper functions into more foundational crates (#11135)

## Description 

`sui-verifier` contained a number of helper functions that were being
used by other crates (like `sui-json`). These helpers don't need to be
versioned as part of the execution layer, but `sui-verifier` in general
does. By moving helpers into `sui-types` and `move-bytecode-utils`
(which are not versioned), we avoid `sui-json` having to deal with the
versioned API.

## Test Plan 

```
$ cargo simtest
$ env SUI_SKIP_SIMTESTS=1 cargo nextest run
```

Author: amnn

tools/move-bytecode-utils/src/lib.rs

@@ -7,8 +7,14 @@ pub mod layout;
 pub mod module_cache;
 
 use crate::dependency_graph::DependencyGraph;
-use move_binary_format::{access::ModuleAccess, file_format::CompiledModule};
-use move_core_types::language_storage::ModuleId;
+use move_binary_format::{
+    access::ModuleAccess,
+    binary_views::BinaryIndexedView,
+    file_format::{CompiledModule, SignatureToken, StructHandleIndex},
+};
+use move_core_types::{
+    account_address::AccountAddress, identifier::IdentStr, language_storage::ModuleId,
+};
 
 use anyhow::{anyhow, Result};
 use std::collections::BTreeMap;
@@ -94,3 +100,71 @@ impl<'a> Modules<'a> {
         Ok(all_deps)
     }
 }
+
+pub fn resolve_struct<'a>(
+    view: &'a BinaryIndexedView,
+    sidx: StructHandleIndex,
+) -> (&'a AccountAddress, &'a IdentStr, &'a IdentStr) {
+    let shandle = view.struct_handle_at(sidx);
+    let mhandle = view.module_handle_at(shandle.module);
+    let address = view.address_identifier_at(mhandle.address);
+    let module_name = view.identifier_at(mhandle.name);
+    let struct_name = view.identifier_at(shandle.name);
+    (address, module_name, struct_name)
+}
+
+pub fn format_signature_token(view: &BinaryIndexedView, t: &SignatureToken) -> String {
+    match t {
+        SignatureToken::Bool => "bool".to_string(),
+        SignatureToken::U8 => "u8".to_string(),
+        SignatureToken::U16 => "u16".to_string(),
+        SignatureToken::U32 => "u32".to_string(),
+        SignatureToken::U64 => "u64".to_string(),
+        SignatureToken::U128 => "u128".to_string(),
+        SignatureToken::U256 => "u256".to_string(),
+        SignatureToken::Address => "address".to_string(),
+        SignatureToken::Signer => "signer".to_string(),
+        SignatureToken::Vector(inner) => {
+            format!("vector<{}>", format_signature_token(view, inner))
+        }
+        SignatureToken::Reference(inner) => format!("&{}", format_signature_token(view, inner)),
+        SignatureToken::MutableReference(inner) => {
+            format!("&mut {}", format_signature_token(view, inner))
+        }
+        SignatureToken::TypeParameter(i) => format!("T{}", i),
+
+        SignatureToken::Struct(idx) => format_signature_token_struct(view, *idx, &[]),
+        SignatureToken::StructInstantiation(idx, ty_args) => {
+            format_signature_token_struct(view, *idx, ty_args)
+        }
+    }
+}
+
+pub fn format_signature_token_struct(
+    view: &BinaryIndexedView,
+    sidx: StructHandleIndex,
+    ty_args: &[SignatureToken],
+) -> String {
+    let (address, module_name, struct_name) = resolve_struct(view, sidx);
+    let s;
+    let ty_args_string = if ty_args.is_empty() {
+        ""
+    } else {
+        s = format!(
+            "<{}>",
+            ty_args
+                .iter()
+                .map(|t| format_signature_token(view, t))
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+        &s
+    };
+    format!(
+        "0x{}::{}::{}{}",
+        address.short_str_lossless(),
+        module_name,
+        struct_name,
+        ty_args_string
+    )
+}