Use read_unaligned when reading u64

Casting an arbitrary pointer to `u64` is an undefined behavior.

Not sure if casting of the discriminator value is really necessary, as
it is just a `u8` in this example.  But using the same
`*ptr.cast::<uXX>()` pattern in there seems wrong.  It is a noop for
`u8`, but if a `u64` is used, it becomes undefined behavior as well.

Also, the `unsafe` usage is somewhat unclear.  Dereferencing a pointer
is an unsafe operation, but the first two examples do not have `unsafe`.
Yet in the last example, when a slice is constructed, `unsafe` is
present.  I assume that the first two examples are expected to be in an
unsafe context already?

Author: illia-bobyr

src/app/content/courses/pinocchio-for-dummies/middleware-entrypoint/en.mdx

@@ -124,9 +124,9 @@ Always verify that account offsets and lengths match expectations. Use [sbpf.xyz
 
 ```rust
 if *input == 4
-    && (*input.add(ACCOUNT1_DATA_LEN).cast::<u64>() == 165)
-    && (*input.add(ACCOUNT2_DATA_LEN).cast::<u64>() == 82)
-    && (*input.add(IX12_ACCOUNT3_DATA_LEN).cast::<u64>() == 165)
+    && (input.add(ACCOUNT1_DATA_LEN).cast::<u64>().read_unaligned() == 165)
+    && (input.add(ACCOUNT2_DATA_LEN).cast::<u64>().read_unaligned() == 82)
+    && (input.add(IX12_ACCOUNT3_DATA_LEN).cast::<u64>().read_unaligned() == 165)
 {
     //...
 }
@@ -145,16 +145,16 @@ fn align(input: u64) -> u64 {
 
 // The `authority` account can have variable data length.
     let account_4_data_len_aligned =
-        align(*input.add(IX12_ACCOUNT4_DATA_LEN).cast::<u64>()) as usize;
+        align(input.add(IX12_ACCOUNT4_DATA_LEN).cast::<u64>().read_unaligned()) as usize;
     let offset = IX12_EXPECTED_INSTRUCTION_DATA_LEN_OFFSET + account_4_data_len_aligned;
 ```
 
 Once validation passes, extract instruction data, transmute accounts, and process normally:
 
 ```rust
 // Check that we have enough instruction data.
-if input.add(offset).cast::<usize>().read() >= INSTRUCTION_DATA_SIZE {
-    let discriminator = input.add(offset + size_of::<u64>()).cast::<u8>().read();
+if unsafe { input.add(offset).cast::<usize>().read_unaligned() } >= INSTRUCTION_DATA_SIZE {
+    let discriminator = unsafe { input.add(offset + size_of::<u64>()).cast::<u8>().read() };
 
     // Check for instruction discriminator.
     if likely(discriminator == 12) {
@@ -179,4 +179,4 @@ if input.add(offset).cast::<usize>().read() >= INSTRUCTION_DATA_SIZE {
         };
     }
 }
-```
+```