Logger-tt

* Fixed:
* TelegramHandler re-grouped an already grouped message. Now messages are correctly grouped once.
* Handlers from all loggers other than the root were mistakenly added to the root's handlers.
This bug prevents the removal of handlers out of the root, thus the log message was doubled if another different handler was used. Now root's handlers are correctly added or removed (thank ZeroRin).

* Usability:
* Multiprocessing:
* Changed the method of detecting child process, potentially fixing all issues related to multiprocessing and pyinstaller
* logger's server port now automatically picks up a random available port instead of `DEFAULT_TCP_LOGGING_PORT`. This means in the case of running many multiprocessing applications at the same time, the user doesn't need to care about the `port` parameter anymore. Each application will pick its port, and its child processes will connect to the correct port, and thus log to the correct destination.
* Added `server_timeout` argument to `setup_logging()`: allow the user to control how long should the log listener server
wait before exiting following the death of the main thread.
* Added `client_only` argument to `setup_logging()`: enable different independent applications to log to the same destination.
* TelegramHandler: If the message is longer than 3072 characters, it will be split into parts and sent one by one.
This is to avoid reaching the Telegram API's limit of 4096 characters per message, which users should rarely reach.
* Format styles: added support for `{` (string.format) and `$` (string.Template) formats. The same style could be used across `fomatter`'s format and log message's format.

* Usability:
* Not to import custom handlers (StreamHandlerWithBuffer, TelegramHandler, etc) if they are not used in any logger.
* TelegramHandler:
* Better network error handling.
* Added `grouping_interval` to group many log messages that are within the same `x` seconds interval into one before sending.
This reduces the number of times it sends messages to the Telegram server and helps to avoid Http-429 error.

* Fixed: exception raised while handling another exception is now shown correctly (thank ZeroRin).
* New functionality:
* Added `TelegramHandler`. Now you can send logs directly to telegram users/groups.
* Support Python 3.11 `Fine-grained error locations` in tracebacks.
* Usability:
* Added level NOTICE = INFO + 5. You can do `logger.notice("your message")`.
* Add set/remove `context injector` methods.
You can add additional information to the log record before it is actually handled.
Refer to the `TelegramHandler` for a usage sample.
* You can now set different log paths for different handlers by passing a dict to `setup_logging` (thank ZeroRin).

* Fixed:
* multiprocessing: logfile rollover fails as the child process keeps opening the file.
* multiprocessing: if the log path is set by a variable with time,
the child process creates a new redundant log path.

* New functionality: Added `StreamHandlerWithBuffer`. Buffer the log output by time or by line number.
GUI app could use this handler to keep the app responsive while having a tremendous log output.

* Usability: In multiprocessing logging,
users can set the log server address themselves through `setup_logging` or log config file.

* Added `limit_line_length` parameter:
log only maximum `n` characters for each traceback line. This prevents dumping the whole huge content of the variable into the log. `n=1000` by default.

* Added `analyze_raise_statement` parameter:
logger-tt no longer analyzes the raise statement by default. This avoids logging value of variables on the raise statement two time, especially when the content of these variables are huge.

1. Exception on the multiline statement
From python 3.6 to 3.9, the `tokenize` module and the exception traceback have changed their behavior. So if a multiline statement raised an exception, the lines reported were different between different python versions. Sometimes, too many unrelated lines were reported too.
* This release tries to mitigate that and grabs all the lines of the multiline statement as correctly as possible.
* If there are too many lines, it limits the line to be shown to 10.

2. Logging uncaught exception in child thread
Child thread is run in a `try-finally` by default, so it doesn't call `sys.excepthook` when an uncaught exception occurred.
So `logger-tt` doesn't receive the traceback to log it.
This release replaces the thread default `try-finally` to `try-except-finally` and `logger-tt` handles the uncaught exception normally.

Python 3.8+ has a new `thread.excepthook`. But since `logger-tt` has already handled the uncaught exception, this `thread.excepthook` won't be called.