Global updates

• implemented proc macroses (LoginPacket, WorldPacket) to provide handy approach to packet building. Macroses support #[dynamic_field] attribute to let user implement own way of parsing field. Also implemented with_opcode! declarative macro to make it easier to attach opcode to packet parser. Opcode is required and should be added via with_opcode! macro or manually if not removed explicitly (need to set #[options(no_opcode)] option on top of struct).
• added support for .env file and such params as host or port to connect are moved into it (file is private and will not be commited)
• on UI side: implemented debug details panel which will appear only in DEBUG mode. Supported scroll via output history by keyboard arrows (up/down), improved MessageIncome::send_<type>_message methods, so it is possible to send string details to show in debug details output. To scroll debug details panel should be used CTRL + arrows (up/down). Also added info panel to show some additional info like total input/output packets and current/total output items (DEBUG only)
• added customizable errors (anyhow and thiserror crates), improved error output, a lot of unwrap are refactored into results

This PR is a part of global project refactoring.

First of all, I implemented WorldPacket and LoginPacket proc macroses to make packets description easier. Also was implemented with_opcode! which is required for outcome packets because proc macros should know how to build header where opcode is used (macros generates Self::opcode() method, so more verbose alternative is just implement this method on the struct). Proc macroses allow to declare dynamic fields, so this field can be built in another way described in method which name should be same as field.

#[derive(WorldPacket, Debug)]
#[options(no_opcode)]
#[allow(dead_code)]
struct Income {
    message_type: u8,
    language: u32,
    sender_guid: u64,
    skip: u32,
    #[dynamic_field]
    channel_name: String,
    target_guid: u64,
    message_length: u32,
    #[dynamic_field]
    message: String,
}

impl Income {
    fn message<R: BufRead>(mut reader: R, initial: &mut Self) -> String {
        let mut buffer = vec![0u8; initial.message_length as usize];
        reader.read_exact(&mut buffer).unwrap();
        String::from_utf8(buffer).unwrap()
    }

    fn channel_name<R: BufRead>(mut reader: R, initial: &mut Self) -> String {
        if initial.message_type == MessageType::CHANNEL {
            let mut buffer = Vec::new();
            reader.read_until(0, &mut buffer).unwrap();
            String::from_utf8(buffer).unwrap()
        } else {
            String::default()
        }
    }
}

dynamic field can be used in case when need to parse field conditionally or when field depends on another field. Also it is possible to build packets with dynamic opcode, for this purpose need to use .unpack_with_opcode(opcode) on Outcome packets instead of just .unpack().

fn build_movement_packet(
    opcode: u32,
    guid: u64,
    new_position: Position,
    movement_flags: MovementFlags
) -> (u32, Vec<u8>) {
    let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
    Outcome {
        guid: PackedGuid(guid),
        movement_flags: movement_flags.bits(),
        movement_flags2: MovementFlagsExtra::NONE.bits(),
        // TODO: need to investigate how better get u32 value from timestamp
        time: now.as_millis() as u32,
        x: new_position.x,
        y: new_position.y,
        z: new_position.z,
        direction: new_position.orientation,
        unknown: 0
    }.unpack_with_opcode(opcode)
}

Also within this PR added pretty output for packet details, fixed UI history scrolling (when select specific output details panel show wrong text).

Added support for .env files to store sensitive data (currently host to connect).

Refactored .send_<>_message methods of MessageIncome, now this methods receive extra optional String param to allow output extra data in debug details panel.

UI updates

• Added extra info panel to show additional output (incoming/outcoming counter; in DEBUG mode shows selected/total items).
• Added scrolling for details panel (using CTRL + arrows UP/DOWN)
• Added support for PageUp/PageDown fast scroll; added support for Home/End fast scroll to select first/last item in output
• Fixed UI freeze when switch between modes

Within this PR added next features:

• added extra panel that will be displayed in DEBUG mode, this panel need to output extra details on debug messages
• added scrolling through messages history (client stores last selected message, so if turn off DEBUG mode output will be scrolled to most recent message, but when turn on again client will scroll to last selected message)

Notice: history scrolling will work ONLY in DEBUG mode. For now I see no sense to allow it without extra output.

Handlers now async, so async code is possible to be used directly there. Also were fixed deadlocks by decreasing scope of mutex using. Packet reader was fixed and now it works correctly when server send partial packet (see BufReader in stream.rs).

In this PR:

• added modes support (currently only debug mode, later will be added more modes). Each mode affect client flag, then affect internal UI renderer state. This state will be used for internal components.
• refactored key input processing (so each component handle own part)

Within this PR:

• added popup for select character and popup for select realm
• support keyboard events (resize and mouse supported but not used for now)
• refactored file structure and code, all interprocess communication (ipc) structures were moved into ipc dir
• added HandlerOutput::Freeze type which should be used when need to wait for user input
• replaced async mutex with std::sync::mutex, this way deadlocks were fixed
• replaced async packet read with immediate try_read, so now app should be faster (since there no need to fix read timeout according to server)
• refactored way of how handlers processed. Now each handler result processed immediately, so it's more convenient to process handler result
• some I/O tasks were refactored to be spawn via spawn_blocking to guarantee that spawn will be inside another thread. This way keyboard output become processed immediately

Within this feature was used tui-rs crate to implement base layout for my application.

Now instead of println! output all data is send to UI using mpsc channel.

On local side tests runned OK, on github actions almost all tests where I use TCP connection are failed. Within this branch trying to find the reason.