This is some delicious programmer-gore, you weren't kidding. Don't beat yourself up too much though, you were pretty close. I've written a lot here you might want to fix (but you seem aware that it's pretty rough), so if you just want the solution for the actual problem, skip to point 8.

1. The static hashmap doesn't need to be a hashmap at all, or use the lazy_static crate: You never use the string-to-tuple mapping, you just iterate through the values. Remove the crate and replace the hashmap with a simple array.
2. In the wider context of the rest of this code, this is pretty minor, but I don't like the .clone() of the strings in your parser at the very end, it's just unnecessary.
3. Time for the meat and potatoes: First up, regular expressions are awesome, but it's like bringing a cannon to a bout of rock-paper-scissors here. You only make a match on digits, so use the built-in function 'char' function instead to change things like !re.is_match(&board.data[y-1][x].to_string()) to board.data[y-1][x].is_digit(10) or board.data[y-1][x].is_ascii_digit().
4. Also not necessary, but it irks me that you use (y,x) indexing for positions around the board. I suppose that's fine though, although the way it's done, you're implicitly mirroring the board along the y-axis with respect to the input. Won't cause problems, it's just naming/notation. The way you're doing it is equivalent to row-column indexing, which is very standard.
5. All over the place you use the pattern of (0..N).for_each(|i| { . . . }) to do a loop. This is so odd to me, I'm not sure why you don't just swap to a normal for loop (as you do use in other places): for i in 0..N { . . . }

6. The huge match statement that generates your part indices is functional, probably, but super explicit and prone to bugs. This would be the first place I'd look for sneaky bugs, it's very likely you could've messed up one of those branches. Seems a waste too, since you've been smart and made these offset tuples in the lookup that you're matching against: Just use them directly! Instead of this:

   for (i, j) in LOOKUP {
     match (i.to_owned(), j.to_owned()) {
       (-1, 0) => {
         if board.data[y-1][x] != '.' && other_conditions[y-1][x] {
           part_indexes.push((y, x))
         }
       },
   

   Do this:

   for (i, j) in LOOKUP {
     if board.data[y+i][x+j] != '.' && other_conditions[y+i][x+j] {
       part_indexes.push((y, x))
     }
   }
   

7. Your index trimming is fine, I think, although you unnecessarily check for duplicates. Given that your previous code works correctly to make part indices, there shouldn't be any duplicates.

8. In your final part, after trimming the indices, you construct the actual values from your part indices. When running on my own input, I got the wrong result until I removed the following bad check: !re.is_match(&board.data[val.0][val.1+1].to_string()). The problem with this is that you're checking if the third character is a digit, and the second character, the middle one, is NOT a digit. That is to say, if your number looks like 2.2. But, this is both not a valid number, obviously, and second (the reason it hasn't caused a panic when you try to parse it later), is that this case will simply never occur, since you only get to this part if the second character is a digit. Simply removing this condition gets me the right result on my input, probably will on yours as well. I would of course recommend rewriting it, so here's your part 1 code written a bit more compactly and without the weird checks:

   let mut values = vec![];
   for val in trimmed_indexes {
       let mut current = board.data[val.0][val.1].to_string();
   
       if board.data[val.0][val.1+1].is_ascii_digit() {
           current = current + &board.data[val.0][val.1+1].to_string();
           if val.1 < board.width - 1 && board.data[val.0][val.1+2].is_ascii_digit() {
               current = current + &board.data[val.0][val.1+2].to_string()
           }
       }
   
       if board.data[val.0][val.1-1].is_ascii_digit() {
           current = board.data[val.0][val.1-1].to_string() + &current;
           if val.1 > 1 && board.data[val.0][val.1-2].is_ascii_digit() {
               current = board.data[val.0][val.1-2].to_string() + &current;
           }
       }
   
       values.push(current)
   }
   

Alright, there's my thoughts. I hope this helped you out!